{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How to Extract Training and Prediction Matrices\n",
    "\n",
    "While forecasting models are mainly used to predict future values, it's just as important to understand **how the model is learning from the training data**. Analyzing **input and output matrices** used during training, **predictions on the training data** or exploring the **prediction matrices** is crucial for assessing model performance and understanding areas for optimization. This process can reveal whether the model is overfitting, underfitting, or struggling with specific patterns in the data.\n",
    "\n",
    "**Training matrices**\n",
    "\n",
    "Training matrices contain the input features used by the model during the training process. These matrices are essential for understanding how the model interprets patterns and relationships within the data. They typically include the lagged variables, window features and exogenous variables. By extracting and analyzing these matrices, you can ensure that the input data is correctly structured and aligned with the model’s requirements.\n",
    "\n",
    "\n",
    "**Prediction matrices**\n",
    "\n",
    "Prediction matrices are used to generate forecasts for future values. These matrices incorporate the features necessary for making predictions, such as recent observations (lags), window features and any exogenous variables. Understanding the structure of these matrices is important for debugging and for validating the model’s future predictions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"admonition note\" name=\"html-admonition\" style=\"background: rgba(255,145,0,.1); padding-top: 0px; padding-bottom: 6px; border-radius: 8px; border-left: 8px solid #ff9100; border-color: #ff9100; padding-left: 10px; padding-right: 10px\">\n",
    "\n",
    "<p class=\"title\">\n",
    "    <i style=\"font-size: 18px; color:#ff9100; border-color: #ff1744;\"></i>\n",
    "    <b style=\"color: #ff9100;\"> <span style=\"color: #ff9100;\">&#9888;</span> Warning</b>\n",
    "</p>\n",
    "\n",
    "If any <a href=\"../user_guides/sklearn-transformers-and-pipeline.html\">data transformations</a> and/or <a href=\"../user_guides/time-series-differentiation.html\">differentiation</a>, are applied, they will affect the output matrices. Consequently, the predictions generated in this transformed scale may require additional steps to revert back to the original data scale.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Libraries and data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Libraries\n",
    "# ==============================================================================\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.linear_model import Ridge\n",
    "from lightgbm import LGBMRegressor\n",
    "from skforecast.datasets import fetch_dataset\n",
    "from skforecast.preprocessing import RollingFeatures\n",
    "from skforecast.recursive import ForecasterRecursive, ForecasterRecursiveMultiSeries\n",
    "from skforecast.direct import ForecasterDirect, ForecasterDirectMultiVariate\n",
    "from skforecast.plot import set_dark_theme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">╭────────────────────────────────────── <span style=\"font-weight: bold\">h2o</span> ───────────────────────────────────────╮\n",
       "│ <span style=\"font-weight: bold\">Description:</span>                                                                     │\n",
       "│ Monthly expenditure ($AUD) on corticosteroid drugs that the Australian health    │\n",
       "│ system had between 1991 and 2008.                                                │\n",
       "│                                                                                  │\n",
       "│ <span style=\"font-weight: bold\">Source:</span>                                                                          │\n",
       "│ Hyndman R (2023). fpp3: Data for Forecasting: Principles and Practice(3rd        │\n",
       "│ Edition). http://pkg.robjhyndman.com/fpp3package/,https://github.com/robjhyndman │\n",
       "│ /fpp3package, http://OTexts.com/fpp3.                                            │\n",
       "│                                                                                  │\n",
       "│ <span style=\"font-weight: bold\">URL:</span>                                                                             │\n",
       "│ https://raw.githubusercontent.com/skforecast/skforecast-                         │\n",
       "│ datasets/main/data/h2o.csv                                                       │\n",
       "│                                                                                  │\n",
       "│ <span style=\"font-weight: bold\">Shape:</span> 204 rows x 2 columns                                                      │\n",
       "╰──────────────────────────────────────────────────────────────────────────────────╯\n",
       "</pre>\n"
      ],
      "text/plain": [
       "╭────────────────────────────────────── \u001b[1mh2o\u001b[0m ───────────────────────────────────────╮\n",
       "│ \u001b[1mDescription:\u001b[0m                                                                     │\n",
       "│ Monthly expenditure ($AUD) on corticosteroid drugs that the Australian health    │\n",
       "│ system had between 1991 and 2008.                                                │\n",
       "│                                                                                  │\n",
       "│ \u001b[1mSource:\u001b[0m                                                                          │\n",
       "│ Hyndman R (2023). fpp3: Data for Forecasting: Principles and Practice(3rd        │\n",
       "│ Edition). http://pkg.robjhyndman.com/fpp3package/,https://github.com/robjhyndman │\n",
       "│ /fpp3package, http://OTexts.com/fpp3.                                            │\n",
       "│                                                                                  │\n",
       "│ \u001b[1mURL:\u001b[0m                                                                             │\n",
       "│ https://raw.githubusercontent.com/skforecast/skforecast-                         │\n",
       "│ datasets/main/data/h2o.csv                                                       │\n",
       "│                                                                                  │\n",
       "│ \u001b[1mShape:\u001b[0m 204 rows x 2 columns                                                      │\n",
       "╰──────────────────────────────────────────────────────────────────────────────────╯\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">╭─────────────────────── <span style=\"font-weight: bold\">items_sales</span> ───────────────────────╮\n",
       "│ <span style=\"font-weight: bold\">Description:</span>                                              │\n",
       "│ Simulated time series for the sales of 3 different items. │\n",
       "│                                                           │\n",
       "│ <span style=\"font-weight: bold\">Source:</span>                                                   │\n",
       "│ Simulated data.                                           │\n",
       "│                                                           │\n",
       "│ <span style=\"font-weight: bold\">URL:</span>                                                      │\n",
       "│ https://raw.githubusercontent.com/skforecast/skforecast-  │\n",
       "│ datasets/main/data/simulated_items_sales.csv              │\n",
       "│                                                           │\n",
       "│ <span style=\"font-weight: bold\">Shape:</span> 1097 rows x 3 columns                              │\n",
       "╰───────────────────────────────────────────────────────────╯\n",
       "</pre>\n"
      ],
      "text/plain": [
       "╭─────────────────────── \u001b[1mitems_sales\u001b[0m ───────────────────────╮\n",
       "│ \u001b[1mDescription:\u001b[0m                                              │\n",
       "│ Simulated time series for the sales of 3 different items. │\n",
       "│                                                           │\n",
       "│ \u001b[1mSource:\u001b[0m                                                   │\n",
       "│ Simulated data.                                           │\n",
       "│                                                           │\n",
       "│ \u001b[1mURL:\u001b[0m                                                      │\n",
       "│ https://raw.githubusercontent.com/skforecast/skforecast-  │\n",
       "│ datasets/main/data/simulated_items_sales.csv              │\n",
       "│                                                           │\n",
       "│ \u001b[1mShape:\u001b[0m 1097 rows x 3 columns                              │\n",
       "╰───────────────────────────────────────────────────────────╯\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">╭──────────────────────── <span style=\"font-weight: bold\">air_quality_valencia_no_missing</span> ─────────────────────────╮\n",
       "│ <span style=\"font-weight: bold\">Description:</span>                                                                     │\n",
       "│ Hourly measures of several air chemical pollutant at Valencia city (Avd.         │\n",
       "│ Francia) from 2019-01-01 to 20213-12-31. Including the following variables:      │\n",
       "│ pm2.5 (µg/m³), CO (mg/m³), NO (µg/m³), NO2 (µg/m³), PM10 (µg/m³), NOx (µg/m³),   │\n",
       "│ O3 (µg/m³), Veloc. (m/s), Direc. (degrees), SO2 (µg/m³). Missing values have     │\n",
       "│ been imputed using linear interpolation.                                         │\n",
       "│                                                                                  │\n",
       "│ <span style=\"font-weight: bold\">Source:</span>                                                                          │\n",
       "│ Red de Vigilancia y Control de la Contaminación Atmosférica, 46250047-València - │\n",
       "│ Av. França, https://mediambient.gva.es/es/web/calidad-ambiental/datos-           │\n",
       "│ historicos.                                                                      │\n",
       "│                                                                                  │\n",
       "│ <span style=\"font-weight: bold\">URL:</span>                                                                             │\n",
       "│ https://raw.githubusercontent.com/skforecast/skforecast-                         │\n",
       "│ datasets/main/data/air_quality_valencia_no_missing.csv                           │\n",
       "│                                                                                  │\n",
       "│ <span style=\"font-weight: bold\">Shape:</span> 43824 rows x 10 columns                                                   │\n",
       "╰──────────────────────────────────────────────────────────────────────────────────╯\n",
       "</pre>\n"
      ],
      "text/plain": [
       "╭──────────────────────── \u001b[1mair_quality_valencia_no_missing\u001b[0m ─────────────────────────╮\n",
       "│ \u001b[1mDescription:\u001b[0m                                                                     │\n",
       "│ Hourly measures of several air chemical pollutant at Valencia city (Avd.         │\n",
       "│ Francia) from 2019-01-01 to 20213-12-31. Including the following variables:      │\n",
       "│ pm2.5 (µg/m³), CO (mg/m³), NO (µg/m³), NO2 (µg/m³), PM10 (µg/m³), NOx (µg/m³),   │\n",
       "│ O3 (µg/m³), Veloc. (m/s), Direc. (degrees), SO2 (µg/m³). Missing values have     │\n",
       "│ been imputed using linear interpolation.                                         │\n",
       "│                                                                                  │\n",
       "│ \u001b[1mSource:\u001b[0m                                                                          │\n",
       "│ Red de Vigilancia y Control de la Contaminación Atmosférica, 46250047-València - │\n",
       "│ Av. França, https://mediambient.gva.es/es/web/calidad-ambiental/datos-           │\n",
       "│ historicos.                                                                      │\n",
       "│                                                                                  │\n",
       "│ \u001b[1mURL:\u001b[0m                                                                             │\n",
       "│ https://raw.githubusercontent.com/skforecast/skforecast-                         │\n",
       "│ datasets/main/data/air_quality_valencia_no_missing.csv                           │\n",
       "│                                                                                  │\n",
       "│ \u001b[1mShape:\u001b[0m 43824 rows x 10 columns                                                   │\n",
       "╰──────────────────────────────────────────────────────────────────────────────────╯\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Download data single series\n",
    "# ==============================================================================\n",
    "data = fetch_dataset(\n",
    "    name=\"h2o\", kwargs_read_csv={\"names\": [\"y\", \"datetime\"], \"header\": 0}\n",
    ")\n",
    "print(\"\")\n",
    "\n",
    "data['datetime'] = pd.to_datetime(data['datetime'], format='%Y-%m-%d')\n",
    "data = data.set_index('datetime')\n",
    "data = data.asfreq('MS')\n",
    "data = data.sort_index()\n",
    "\n",
    "# Download data ForecasterRecursiveMultiSeries\n",
    "# ==============================================================================\n",
    "data_multiseries = fetch_dataset(name=\"items_sales\")\n",
    "print(\"\")\n",
    "\n",
    "# Download data ForecasterDirectMultiVariate\n",
    "# ==============================================================================\n",
    "data_multivariate = fetch_dataset(name=\"air_quality_valencia_no_missing\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ForecasterRecursive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>y</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>datetime</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1991-07-01</th>\n",
       "      <td>0.429795</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1991-08-01</th>\n",
       "      <td>0.400906</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1991-09-01</th>\n",
       "      <td>0.432159</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   y\n",
       "datetime            \n",
       "1991-07-01  0.429795\n",
       "1991-08-01  0.400906\n",
       "1991-09-01  0.432159"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Data\n",
    "# ==============================================================================\n",
    "display(data.head(3))\n",
    "\n",
    "# Plot\n",
    "# ==============================================================================\n",
    "set_dark_theme()\n",
    "fig, ax = plt.subplots(figsize=(6, 3))\n",
    "data['y'].plot(ax=ax)\n",
    "ax.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <style>\n",
       "        .container-8fcc4cda0b034b8da5c4223f274c0002 {\n",
       "            font-family: 'Arial', sans-serif;\n",
       "            font-size: 0.9em;\n",
       "            color: #333333;\n",
       "            border: 1px solid #ddd;\n",
       "            background-color: #f0f8ff;\n",
       "            padding: 5px 15px;\n",
       "            border-radius: 8px;\n",
       "            max-width: 600px;\n",
       "            #margin: auto;\n",
       "        }\n",
       "        .container-8fcc4cda0b034b8da5c4223f274c0002 h2 {\n",
       "            font-size: 1.5em;\n",
       "            color: #222222;\n",
       "            border-bottom: 2px solid #ddd;\n",
       "            padding-bottom: 5px;\n",
       "            margin-bottom: 15px;\n",
       "            margin-top: 5px;\n",
       "        }\n",
       "        .container-8fcc4cda0b034b8da5c4223f274c0002 details {\n",
       "            margin: 10px 0;\n",
       "        }\n",
       "        .container-8fcc4cda0b034b8da5c4223f274c0002 summary {\n",
       "            font-weight: bold;\n",
       "            font-size: 1.1em;\n",
       "            color: #000000;\n",
       "            cursor: pointer;\n",
       "            margin-bottom: 5px;\n",
       "            background-color: #b3dbfd;\n",
       "            padding: 5px;\n",
       "            border-radius: 5px;\n",
       "        }\n",
       "        .container-8fcc4cda0b034b8da5c4223f274c0002 summary:hover {\n",
       "            color: #000000;\n",
       "            background-color: #e0e0e0;\n",
       "        }\n",
       "        .container-8fcc4cda0b034b8da5c4223f274c0002 ul {\n",
       "            font-family: 'Courier New', monospace;\n",
       "            list-style-type: none;\n",
       "            padding-left: 20px;\n",
       "            margin: 10px 0;\n",
       "            line-height: normal;\n",
       "        }\n",
       "        .container-8fcc4cda0b034b8da5c4223f274c0002 li {\n",
       "            margin: 5px 0;\n",
       "            font-family: 'Courier New', monospace;\n",
       "        }\n",
       "        .container-8fcc4cda0b034b8da5c4223f274c0002 li strong {\n",
       "            font-weight: bold;\n",
       "            color: #444444;\n",
       "        }\n",
       "        .container-8fcc4cda0b034b8da5c4223f274c0002 li::before {\n",
       "            content: \"- \";\n",
       "            color: #666666;\n",
       "        }\n",
       "        .container-8fcc4cda0b034b8da5c4223f274c0002 a {\n",
       "            color: #001633;\n",
       "            text-decoration: none;\n",
       "        }\n",
       "        .container-8fcc4cda0b034b8da5c4223f274c0002 a:hover {\n",
       "            color: #359ccb; \n",
       "        }\n",
       "    </style>\n",
       "    \n",
       "        <div class=\"container-8fcc4cda0b034b8da5c4223f274c0002\">\n",
       "            <p style=\"font-size: 1.5em; font-weight: bold; margin-block-start: 0.83em; margin-block-end: 0.83em;\">ForecasterRecursive</p>\n",
       "            <details open>\n",
       "                <summary>General Information</summary>\n",
       "                <ul>\n",
       "                    <li><strong>Estimator:</strong> LGBMRegressor</li>\n",
       "                    <li><strong>Lags:</strong> [1 2 3 4 5]</li>\n",
       "                    <li><strong>Window features:</strong> ['roll_mean_5', 'roll_sum_5']</li>\n",
       "                    <li><strong>Window size:</strong> 5</li>\n",
       "                    <li><strong>Series name:</strong> y</li>\n",
       "                    <li><strong>Exogenous included:</strong> False</li>\n",
       "                    <li><strong>Weight function included:</strong> False</li>\n",
       "                    <li><strong>Differentiation order:</strong> None</li>\n",
       "                    <li><strong>Creation date:</strong> 2025-11-27 12:06:11</li>\n",
       "                    <li><strong>Last fit date:</strong> 2025-11-27 12:06:12</li>\n",
       "                    <li><strong>Skforecast version:</strong> 0.19.0</li>\n",
       "                    <li><strong>Python version:</strong> 3.12.11</li>\n",
       "                    <li><strong>Forecaster id:</strong> None</li>\n",
       "                </ul>\n",
       "            </details>\n",
       "            <details>\n",
       "                <summary>Exogenous Variables</summary>\n",
       "                <ul>\n",
       "                    None\n",
       "                </ul>\n",
       "            </details>\n",
       "            <details>\n",
       "                <summary>Data Transformations</summary>\n",
       "                <ul>\n",
       "                    <li><strong>Transformer for y:</strong> None</li>\n",
       "                    <li><strong>Transformer for exog:</strong> None</li>\n",
       "                </ul>\n",
       "            </details>\n",
       "            <details>\n",
       "                <summary>Training Information</summary>\n",
       "                <ul>\n",
       "                    <li><strong>Training range:</strong> [Timestamp('1991-07-01 00:00:00'), Timestamp('2008-06-01 00:00:00')]</li>\n",
       "                    <li><strong>Training index type:</strong> DatetimeIndex</li>\n",
       "                    <li><strong>Training index frequency:</strong> <MonthBegin></li>\n",
       "                </ul>\n",
       "            </details>\n",
       "            <details>\n",
       "                <summary>Estimator Parameters</summary>\n",
       "                <ul>\n",
       "                    {'boosting_type': 'gbdt', 'class_weight': None, 'colsample_bytree': 1.0, 'importance_type': 'split', 'learning_rate': 0.1, 'max_depth': -1, 'min_child_samples': 20, 'min_child_weight': 0.001, 'min_split_gain': 0.0, 'n_estimators': 100, 'n_jobs': None, 'num_leaves': 31, 'objective': None, 'random_state': 123, 'reg_alpha': 0.0, 'reg_lambda': 0.0, 'subsample': 1.0, 'subsample_for_bin': 200000, 'subsample_freq': 0, 'verbose': -1}\n",
       "                </ul>\n",
       "            </details>\n",
       "            <details>\n",
       "                <summary>Fit Kwargs</summary>\n",
       "                <ul>\n",
       "                    {}\n",
       "                </ul>\n",
       "            </details>\n",
       "            <p>\n",
       "                <a href=\"https://skforecast.org/0.19.0/api/forecasterrecursive.html\">&#128712 <strong>API Reference</strong></a>\n",
       "                &nbsp;&nbsp;\n",
       "                <a href=\"https://skforecast.org/0.19.0/user_guides/autoregressive-forecaster.html\">&#128462 <strong>User Guide</strong></a>\n",
       "            </p>\n",
       "        </div>\n",
       "        "
      ],
      "text/plain": [
       "=================== \n",
       "ForecasterRecursive \n",
       "=================== \n",
       "Estimator: LGBMRegressor \n",
       "Lags: [1 2 3 4 5] \n",
       "Window features: ['roll_mean_5', 'roll_sum_5'] \n",
       "Window size: 5 \n",
       "Series name: y \n",
       "Exogenous included: False \n",
       "Exogenous names: None \n",
       "Transformer for y: None \n",
       "Transformer for exog: None \n",
       "Weight function included: False \n",
       "Differentiation order: None \n",
       "Training range: [Timestamp('1991-07-01 00:00:00'), Timestamp('2008-06-01 00:00:00')] \n",
       "Training index type: DatetimeIndex \n",
       "Training index frequency: <MonthBegin> \n",
       "Estimator parameters: \n",
       "    {'boosting_type': 'gbdt', 'class_weight': None, 'colsample_bytree': 1.0,\n",
       "    'importance_type': 'split', 'learning_rate': 0.1, 'max_depth': -1,\n",
       "    'min_child_samples': 20, 'min_child_weight': 0.001, 'min_split_gain': 0.0,\n",
       "    'n_estimators': 100, 'n_jobs': None, 'num_leaves': 31, 'objective': None,\n",
       "    'random_state': 123, 'reg_alpha': 0.0, 'reg_lambda': 0.0, 'subsample': 1.0,\n",
       "    'subsample_for_bin': 200000, 'subsample_freq': 0, 'verbose': -1} \n",
       "fit_kwargs: {} \n",
       "Creation date: 2025-11-27 12:06:11 \n",
       "Last fit date: 2025-11-27 12:06:12 \n",
       "Skforecast version: 0.19.0 \n",
       "Python version: 3.12.11 \n",
       "Forecaster id: None "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create and fit forecaster\n",
    "# ==============================================================================\n",
    "window_features = RollingFeatures(\n",
    "                      stats        = ['mean', 'sum'],\n",
    "                      window_sizes = [5, 5]\n",
    "                  )\n",
    "\n",
    "forecaster = ForecasterRecursive(\n",
    "                 estimator       = LGBMRegressor(random_state=123, verbose=-1),\n",
    "                 lags            = 5,\n",
    "                 window_features = window_features\n",
    "             )\n",
    "\n",
    "forecaster.fit(y=data['y'])\n",
    "forecaster"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create training matrices\n",
    "# ==============================================================================\n",
    "X_train, y_train = forecaster.create_train_X_y(y=data['y'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>lag_1</th>\n",
       "      <th>lag_2</th>\n",
       "      <th>lag_3</th>\n",
       "      <th>lag_4</th>\n",
       "      <th>lag_5</th>\n",
       "      <th>roll_mean_5</th>\n",
       "      <th>roll_sum_5</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>datetime</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1991-12-01</th>\n",
       "      <td>0.502369</td>\n",
       "      <td>0.492543</td>\n",
       "      <td>0.432159</td>\n",
       "      <td>0.400906</td>\n",
       "      <td>0.429795</td>\n",
       "      <td>0.451554</td>\n",
       "      <td>2.257772</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1992-01-01</th>\n",
       "      <td>0.602652</td>\n",
       "      <td>0.502369</td>\n",
       "      <td>0.492543</td>\n",
       "      <td>0.432159</td>\n",
       "      <td>0.400906</td>\n",
       "      <td>0.486126</td>\n",
       "      <td>2.430629</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1992-02-01</th>\n",
       "      <td>0.660119</td>\n",
       "      <td>0.602652</td>\n",
       "      <td>0.502369</td>\n",
       "      <td>0.492543</td>\n",
       "      <td>0.432159</td>\n",
       "      <td>0.537968</td>\n",
       "      <td>2.689842</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               lag_1     lag_2     lag_3     lag_4     lag_5  roll_mean_5  \\\n",
       "datetime                                                                    \n",
       "1991-12-01  0.502369  0.492543  0.432159  0.400906  0.429795     0.451554   \n",
       "1992-01-01  0.602652  0.502369  0.492543  0.432159  0.400906     0.486126   \n",
       "1992-02-01  0.660119  0.602652  0.502369  0.492543  0.432159     0.537968   \n",
       "\n",
       "            roll_sum_5  \n",
       "datetime                \n",
       "1991-12-01    2.257772  \n",
       "1992-01-01    2.430629  \n",
       "1992-02-01    2.689842  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Predictors matrix\n",
    "# ==============================================================================\n",
    "X_train.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime\n",
       "1991-12-01    0.602652\n",
       "1992-01-01    0.660119\n",
       "1992-02-01    0.336220\n",
       "Freq: MS, Name: y, dtype: float64"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Target variable matrix\n",
    "# ==============================================================================\n",
    "y_train.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can obtain the training predictions using the `predict` method of the estimator stored inside the forecaster object. By examining the predictions on the training data, analysts can get a better understanding of how the model is performing and make adjustments as necessary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.49322601, 0.6376049 , 0.58531495, 0.44962278])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Training predictions using the internal estimator\n",
    "# ==============================================================================\n",
    "predictions_training = forecaster.estimator.predict(X_train)\n",
    "predictions_training[:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Skforecast** provides the `create_predict_X` method to generate the matrices that the forecaster is using to make predictions. This method can be used to gain insight into the specific data manipulations that occur during the prediction process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>lag_1</th>\n",
       "      <th>lag_2</th>\n",
       "      <th>lag_3</th>\n",
       "      <th>lag_4</th>\n",
       "      <th>lag_5</th>\n",
       "      <th>roll_mean_5</th>\n",
       "      <th>roll_sum_5</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2008-07-01</th>\n",
       "      <td>0.762137</td>\n",
       "      <td>0.816255</td>\n",
       "      <td>0.827887</td>\n",
       "      <td>0.649435</td>\n",
       "      <td>0.761822</td>\n",
       "      <td>0.763507</td>\n",
       "      <td>3.817536</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2008-08-01</th>\n",
       "      <td>0.865361</td>\n",
       "      <td>0.762137</td>\n",
       "      <td>0.816255</td>\n",
       "      <td>0.827887</td>\n",
       "      <td>0.649435</td>\n",
       "      <td>0.784215</td>\n",
       "      <td>3.921075</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2008-09-01</th>\n",
       "      <td>0.878167</td>\n",
       "      <td>0.865361</td>\n",
       "      <td>0.762137</td>\n",
       "      <td>0.816255</td>\n",
       "      <td>0.827887</td>\n",
       "      <td>0.829961</td>\n",
       "      <td>4.149806</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2008-10-01</th>\n",
       "      <td>0.806708</td>\n",
       "      <td>0.878167</td>\n",
       "      <td>0.865361</td>\n",
       "      <td>0.762137</td>\n",
       "      <td>0.816255</td>\n",
       "      <td>0.825726</td>\n",
       "      <td>4.128628</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2008-11-01</th>\n",
       "      <td>0.873597</td>\n",
       "      <td>0.806708</td>\n",
       "      <td>0.878167</td>\n",
       "      <td>0.865361</td>\n",
       "      <td>0.762137</td>\n",
       "      <td>0.837194</td>\n",
       "      <td>4.185970</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               lag_1     lag_2     lag_3     lag_4     lag_5  roll_mean_5  \\\n",
       "2008-07-01  0.762137  0.816255  0.827887  0.649435  0.761822     0.763507   \n",
       "2008-08-01  0.865361  0.762137  0.816255  0.827887  0.649435     0.784215   \n",
       "2008-09-01  0.878167  0.865361  0.762137  0.816255  0.827887     0.829961   \n",
       "2008-10-01  0.806708  0.878167  0.865361  0.762137  0.816255     0.825726   \n",
       "2008-11-01  0.873597  0.806708  0.878167  0.865361  0.762137     0.837194   \n",
       "\n",
       "            roll_sum_5  \n",
       "2008-07-01    3.817536  \n",
       "2008-08-01    3.921075  \n",
       "2008-09-01    4.149806  \n",
       "2008-10-01    4.128628  \n",
       "2008-11-01    4.185970  "
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create input matrix for predict method\n",
    "# ==============================================================================\n",
    "X_predict = forecaster.create_predict_X(steps=5)\n",
    "X_predict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.86536052, 0.87816664, 0.80670845, 0.87359717, 0.96601636])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Predict using the internal estimator\n",
    "# ==============================================================================\n",
    "predictions = forecaster.estimator.predict(X_predict)\n",
    "predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ForecasterDirect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create and fit forecaster\n",
    "# ==============================================================================\n",
    "window_features = RollingFeatures(\n",
    "                      stats        = ['mean', 'sum'],\n",
    "                      window_sizes = [5, 5]\n",
    "                  )\n",
    "\n",
    "forecaster = ForecasterDirect(\n",
    "                 estimator       = Ridge(random_state=123),\n",
    "                 steps           = 3,\n",
    "                 lags            = 5,\n",
    "                 window_features = window_features\n",
    "             )\n",
    "\n",
    "forecaster.fit(y=data['y'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two steps are required to extract the training matrices. One to create the entire training matrix and a second to subset the data needed for each model (step)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>lag_1</th>\n",
       "      <th>lag_2</th>\n",
       "      <th>lag_3</th>\n",
       "      <th>lag_4</th>\n",
       "      <th>lag_5</th>\n",
       "      <th>roll_mean_5</th>\n",
       "      <th>roll_sum_5</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>datetime</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1991-12-01</th>\n",
       "      <td>0.502369</td>\n",
       "      <td>0.492543</td>\n",
       "      <td>0.432159</td>\n",
       "      <td>0.400906</td>\n",
       "      <td>0.429795</td>\n",
       "      <td>0.451554</td>\n",
       "      <td>2.257772</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1992-01-01</th>\n",
       "      <td>0.602652</td>\n",
       "      <td>0.502369</td>\n",
       "      <td>0.492543</td>\n",
       "      <td>0.432159</td>\n",
       "      <td>0.400906</td>\n",
       "      <td>0.486126</td>\n",
       "      <td>2.430629</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1992-02-01</th>\n",
       "      <td>0.660119</td>\n",
       "      <td>0.602652</td>\n",
       "      <td>0.502369</td>\n",
       "      <td>0.492543</td>\n",
       "      <td>0.432159</td>\n",
       "      <td>0.537968</td>\n",
       "      <td>2.689842</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1992-03-01</th>\n",
       "      <td>0.336220</td>\n",
       "      <td>0.660119</td>\n",
       "      <td>0.602652</td>\n",
       "      <td>0.502369</td>\n",
       "      <td>0.492543</td>\n",
       "      <td>0.518781</td>\n",
       "      <td>2.593903</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               lag_1     lag_2     lag_3     lag_4     lag_5  roll_mean_5  \\\n",
       "datetime                                                                    \n",
       "1991-12-01  0.502369  0.492543  0.432159  0.400906  0.429795     0.451554   \n",
       "1992-01-01  0.602652  0.502369  0.492543  0.432159  0.400906     0.486126   \n",
       "1992-02-01  0.660119  0.602652  0.502369  0.492543  0.432159     0.537968   \n",
       "1992-03-01  0.336220  0.660119  0.602652  0.502369  0.492543     0.518781   \n",
       "\n",
       "            roll_sum_5  \n",
       "datetime                \n",
       "1991-12-01    2.257772  \n",
       "1992-01-01    2.430629  \n",
       "1992-02-01    2.689842  \n",
       "1992-03-01    2.593903  "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create the whole train matrix\n",
    "# ==============================================================================\n",
    "X_train, y_train = forecaster.create_train_X_y(y=data['y'])\n",
    "\n",
    "# Extract X and y for step 1\n",
    "X_train_1, y_train_1 = forecaster.filter_train_X_y_for_step(\n",
    "                           step          = 1,\n",
    "                           X_train       = X_train,\n",
    "                           y_train       = y_train,\n",
    "                           remove_suffix = False\n",
    "                       )\n",
    "\n",
    "X_train_1.head(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime\n",
       "1991-12-01    0.602652\n",
       "1992-01-01    0.660119\n",
       "1992-02-01    0.336220\n",
       "Freq: MS, Name: y_step_1, dtype: float64"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Target variable matrix for step 1\n",
    "# ==============================================================================\n",
    "y_train_1.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{np.int64(1): Ridge(random_state=123),\n",
       " np.int64(2): Ridge(random_state=123),\n",
       " np.int64(3): Ridge(random_state=123)}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Internal estimators {step: estimator}\n",
    "# ==============================================================================\n",
    "forecaster.estimators_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.5960254 , 0.6592509 , 0.70209408, 0.50312286])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Step 1 training predictions using the internal estimator\n",
    "# ==============================================================================\n",
    "predictions_training = forecaster.estimators_[1].predict(X_train_1)\n",
    "predictions_training[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>lag_1</th>\n",
       "      <th>lag_2</th>\n",
       "      <th>lag_3</th>\n",
       "      <th>lag_4</th>\n",
       "      <th>lag_5</th>\n",
       "      <th>roll_mean_5</th>\n",
       "      <th>roll_sum_5</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2008-07-01</th>\n",
       "      <td>0.762137</td>\n",
       "      <td>0.816255</td>\n",
       "      <td>0.827887</td>\n",
       "      <td>0.649435</td>\n",
       "      <td>0.761822</td>\n",
       "      <td>0.763507</td>\n",
       "      <td>3.817536</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2008-08-01</th>\n",
       "      <td>0.762137</td>\n",
       "      <td>0.816255</td>\n",
       "      <td>0.827887</td>\n",
       "      <td>0.649435</td>\n",
       "      <td>0.761822</td>\n",
       "      <td>0.763507</td>\n",
       "      <td>3.817536</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2008-09-01</th>\n",
       "      <td>0.762137</td>\n",
       "      <td>0.816255</td>\n",
       "      <td>0.827887</td>\n",
       "      <td>0.649435</td>\n",
       "      <td>0.761822</td>\n",
       "      <td>0.763507</td>\n",
       "      <td>3.817536</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               lag_1     lag_2     lag_3     lag_4     lag_5  roll_mean_5  \\\n",
       "2008-07-01  0.762137  0.816255  0.827887  0.649435  0.761822     0.763507   \n",
       "2008-08-01  0.762137  0.816255  0.827887  0.649435  0.761822     0.763507   \n",
       "2008-09-01  0.762137  0.816255  0.827887  0.649435  0.761822     0.763507   \n",
       "\n",
       "            roll_sum_5  \n",
       "2008-07-01    3.817536  \n",
       "2008-08-01    3.817536  \n",
       "2008-09-01    3.817536  "
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create input matrix for predict method\n",
    "# ==============================================================================\n",
    "X_predict = forecaster.create_predict_X(steps=None)  # All steps\n",
    "X_predict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.78198225, 0.78198225, 0.78198225])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Step 1 predictions using the internal estimator\n",
    "# ==============================================================================\n",
    "predictions = forecaster.estimators_[1].predict(X_predict)\n",
    "predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating matrices when including transformations\n",
    "\n",
    "If any [data transformations](../user_guides/sklearn-transformers-and-pipeline.html) and/or [differentiation](../user_guides/time-series-differentiation.html), are applied, they will affect the output matrices. Consequently, the predictions generated in this transformed scale may require additional steps to revert back to the original data scale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create and fit ForecasterRecursive\n",
    "# ==============================================================================\n",
    "window_features = RollingFeatures(\n",
    "                      stats        = ['mean', 'sum'],\n",
    "                      window_sizes = [5, 5]\n",
    "                  )\n",
    "\n",
    "forecaster = ForecasterRecursive(\n",
    "                 estimator       = LGBMRegressor(random_state=123, verbose=-1),\n",
    "                 lags            = 5,\n",
    "                 window_features = window_features,\n",
    "                 transformer_y   = StandardScaler(),\n",
    "                 differentiation = 1\n",
    "             )\n",
    "\n",
    "forecaster.fit(y=data['y'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.5547262 , 0.3597327 , 0.39960716, 0.42227145])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Training predictions with transformations\n",
    "# ==============================================================================\n",
    "X_train_transformed, y_train_transformed = forecaster.create_train_X_y(y=data['y'])\n",
    "\n",
    "# Training predictions using the internal estimator\n",
    "predictions_transformed = forecaster.estimator.predict(X_train_transformed)\n",
    "\n",
    "# Revert differentiation (only if differentiation is not None)\n",
    "predictions_transformed = forecaster.differentiator.inverse_transform_training(predictions_transformed)\n",
    "\n",
    "# Revert transformation (only if transformer_y is not None)\n",
    "predictions_training = forecaster.transformer_y.inverse_transform(predictions_transformed.reshape(-1, 1))\n",
    "predictions_training.ravel()[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╭───────────────────────────── DataTransformationWarning ──────────────────────────────╮</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> The output matrix is in the transformed scale due to the inclusion of                <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> transformations or differentiation in the Forecaster. As a result, any predictions   <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> generated using this matrix will also be in the transformed scale. Please refer to   <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> the documentation for more details:                                                  <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> https://skforecast.org/latest/user_guides/training-and-prediction-matrices.html      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>                                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Category : skforecast.exceptions.DataTransformationWarning                           <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Location :                                                                           <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\recursi <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> ve\\_forecaster_recursive.py:1480                                                     <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Suppress : warnings.simplefilter('ignore', category=DataTransformationWarning)       <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╰──────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[38;5;214m╭─\u001b[0m\u001b[38;5;214m────────────────────────────\u001b[0m\u001b[38;5;214m DataTransformationWarning \u001b[0m\u001b[38;5;214m─────────────────────────────\u001b[0m\u001b[38;5;214m─╮\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m The output matrix is in the transformed scale due to the inclusion of                \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m transformations or differentiation in the Forecaster. As a result, any predictions   \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m generated using this matrix will also be in the transformed scale. Please refer to   \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m the documentation for more details:                                                  \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m https://skforecast.org/latest/user_guides/training-and-prediction-matrices.html      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m                                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Category : skforecast.exceptions.DataTransformationWarning                           \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Location :                                                                           \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\recursi \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m ve\\_forecaster_recursive.py:1480                                                     \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Suppress : warnings.simplefilter('ignore', category=DataTransformationWarning)       \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m╰──────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([0.88563047, 0.62235217, 0.54433454, 0.56906843])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Predict using the internal estimator with transformation\n",
    "# ==============================================================================\n",
    "X_predict_transformed = forecaster.create_predict_X(steps=5)\n",
    "\n",
    "# Predict using the internal estimator\n",
    "predictions_transformed = forecaster.estimator.predict(X_predict_transformed)\n",
    "\n",
    "# Revert differentiation (only if differentiation is not None)\n",
    "predictions_transformed = forecaster.differentiator.inverse_transform_next_window(predictions_transformed)\n",
    "\n",
    "# Revert transformation (only if transformer_y is not None)\n",
    "predictions = forecaster.transformer_y.inverse_transform(predictions_transformed.reshape(-1, 1))\n",
    "predictions.ravel()[:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As before, when using a <code>ForecasterDirect</code>, two steps are required to extract the training matrices. One to create the entire training matrix and a second to subset the data needed for each model (step)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"admonition note\" name=\"html-admonition\" style=\"background: rgba(255,145,0,.1); padding-top: 0px; padding-bottom: 6px; border-radius: 8px; border-left: 8px solid #ff9100; border-color: #ff9100; padding-left: 10px; padding-right: 10px\">\n",
    "\n",
    "<p class=\"title\">\n",
    "    <i style=\"font-size: 18px; color:#ff9100; border-color: #ff1744;\"></i>\n",
    "    <b style=\"color: #ff9100;\"> <span style=\"color: #ff9100;\">&#9888;</span> Warning</b>\n",
    "</p>\n",
    "\n",
    "If the <code>ForecasterDirect</code> includes <a href=\"../user_guides/time-series-differentiation.html\">differentiation</a>, the model in step 1 must be used if you want to reverse the differentiation of the training time series with the <code>inverse_transform_training</code> method.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create and fit ForecasterDirect\n",
    "# ==============================================================================\n",
    "window_features = RollingFeatures(\n",
    "                      stats        = ['mean', 'sum'],\n",
    "                      window_sizes = [5, 5]\n",
    "                  )\n",
    "\n",
    "forecaster = ForecasterDirect(\n",
    "                 estimator       = Ridge(random_state=123),\n",
    "                 steps           = 3,\n",
    "                 lags            = 5,\n",
    "                 window_features = window_features,\n",
    "                 transformer_y   = StandardScaler(),\n",
    "                 differentiation = 1\n",
    "             )\n",
    "\n",
    "forecaster.fit(y=data['y'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.58659215, 0.55767068, 0.58243553, 0.58782361])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Training predictions with transformations\n",
    "# ==============================================================================\n",
    "X_train_transformed, y_train_transformed = forecaster.create_train_X_y(y=data['y'])\n",
    "\n",
    "# Extract X and y for step 1\n",
    "X_train_transformed_1, y_train_transformed_1 = forecaster.filter_train_X_y_for_step(\n",
    "                                                   step          = 1,\n",
    "                                                   X_train       = X_train_transformed,\n",
    "                                                   y_train       = y_train_transformed,\n",
    "                                                   remove_suffix = False\n",
    "                                               )\n",
    "\n",
    "# Training predictions using the internal estimator for step 1\n",
    "predictions_transformed = forecaster.estimators_[1].predict(X_train_transformed_1)\n",
    "\n",
    "# Revert differentiation (only if differentiation is not None)\n",
    "predictions_transformed = forecaster.differentiator.inverse_transform_training(predictions_transformed)\n",
    "\n",
    "# Revert transformation (only if transformer_y is not None)\n",
    "predictions_training = forecaster.transformer_y.inverse_transform(predictions_transformed.reshape(-1, 1))\n",
    "predictions_training.ravel()[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╭───────────────────────────── DataTransformationWarning ──────────────────────────────╮</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> The output matrix is in the transformed scale due to the inclusion of                <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> transformations or differentiation in the Forecaster. As a result, any predictions   <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> generated using this matrix will also be in the transformed scale. Please refer to   <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> the documentation for more details:                                                  <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> https://skforecast.org/latest/user_guides/training-and-prediction-matrices.html      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>                                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Category : skforecast.exceptions.DataTransformationWarning                           <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Location :                                                                           <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\direct\\ <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> _forecaster_direct.py:1628                                                           <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Suppress : warnings.simplefilter('ignore', category=DataTransformationWarning)       <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╰──────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[38;5;214m╭─\u001b[0m\u001b[38;5;214m────────────────────────────\u001b[0m\u001b[38;5;214m DataTransformationWarning \u001b[0m\u001b[38;5;214m─────────────────────────────\u001b[0m\u001b[38;5;214m─╮\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m The output matrix is in the transformed scale due to the inclusion of                \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m transformations or differentiation in the Forecaster. As a result, any predictions   \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m generated using this matrix will also be in the transformed scale. Please refer to   \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m the documentation for more details:                                                  \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m https://skforecast.org/latest/user_guides/training-and-prediction-matrices.html      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m                                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Category : skforecast.exceptions.DataTransformationWarning                           \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Location :                                                                           \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\direct\\ \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m _forecaster_direct.py:1628                                                           \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Suppress : warnings.simplefilter('ignore', category=DataTransformationWarning)       \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m╰──────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([0.85739057, 0.95264414, 1.04789772])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Predict using the internal estimator with transformation\n",
    "# ==============================================================================\n",
    "X_predict_transformed = forecaster.create_predict_X(steps=None)  # All steps\n",
    "\n",
    "# Predict using the internal estimator for step 1\n",
    "predictions_transformed = forecaster.estimators_[1].predict(X_predict_transformed)\n",
    "\n",
    "# Revert differentiation (only if differentiation is not None)\n",
    "predictions_transformed = forecaster.differentiator.inverse_transform_next_window(predictions_transformed)\n",
    "\n",
    "# Revert transformation (only if transformer_y is not None)\n",
    "predictions = forecaster.transformer_y.inverse_transform(predictions_transformed.reshape(-1, 1))\n",
    "predictions.ravel()[:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"admonition note\" name=\"html-admonition\" style=\"background: rgba(0,191,191,.1); padding-top: 0px; padding-bottom: 6px; border-radius: 8px; border-left: 8px solid #00bfa5; border-color: #00bfa5; padding-left: 10px; padding-right: 10px;\">\n",
    "\n",
    "<p class=\"title\">\n",
    "    <i style=\"font-size: 18px; color:#00bfa5;\"></i>\n",
    "    <b style=\"color: #00bfa5;\">&#128161 Tip</b>\n",
    "</p>\n",
    "\n",
    "To reverse the <a href=\"../user_guides/sklearn-transformers-and-pipeline.html\">data transformation</a>, you can also use one of these skforecast functions: <a href=\"../api/utils.html#skforecast.utils.utils.transform_numpy\"><code>transform_numpy</code></a>, <a href=\"../api/utils.html#skforecast.utils.utils.transform_series\"><code>transform_series</code></a>, <a href=\"../api/utils.html#skforecast.utils.utils.transform_dataframe\"><code>transform_dataframe</code></a>.\n",
    "\n",
    "```python\n",
    "from skforecast.utils import transform_numpy\n",
    "\n",
    "predictions = transform_numpy(\n",
    "                  array             = predictions_transformed,\n",
    "                  transformer       = forecaster.transformer_y,\n",
    "                  fit               = False,\n",
    "                  inverse_transform = True\n",
    "              )\n",
    "```\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ForecasterRecursiveMultiSeries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>item_1</th>\n",
       "      <th>item_2</th>\n",
       "      <th>item_3</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2012-01-01</th>\n",
       "      <td>8.253175</td>\n",
       "      <td>21.047727</td>\n",
       "      <td>19.429739</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-01-02</th>\n",
       "      <td>22.777826</td>\n",
       "      <td>26.578125</td>\n",
       "      <td>28.009863</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-01-03</th>\n",
       "      <td>27.549099</td>\n",
       "      <td>31.751042</td>\n",
       "      <td>32.078922</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               item_1     item_2     item_3\n",
       "date                                       \n",
       "2012-01-01   8.253175  21.047727  19.429739\n",
       "2012-01-02  22.777826  26.578125  28.009863\n",
       "2012-01-03  27.549099  31.751042  32.078922"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Data\n",
    "# ==============================================================================\n",
    "display(data_multiseries.head(3))\n",
    "\n",
    "# Plot\n",
    "# ==============================================================================\n",
    "fig, axes = plt.subplots(nrows=3, ncols=1, figsize=(9, 4), sharex=True)\n",
    "\n",
    "for i, col in enumerate(data_multiseries.columns):\n",
    "    data_multiseries[col].plot(ax=axes[i])\n",
    "    axes[i].set_xlabel('')\n",
    "    axes[i].set_ylabel('sales')\n",
    "    axes[i].set_title(col)\n",
    "\n",
    "fig.tight_layout()\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╭────────────────────────────────── InputTypeWarning ──────────────────────────────────╮</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Passing a DataFrame (either wide or long format) as `series` requires additional     <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> internal transformations, which can increase computational time. It is recommended   <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> to use a dictionary of pandas Series instead. For more details, see:                 <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> https://skforecast.org/latest/user_guides/independent-multi-time-series-forecasting. <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> html#input-data                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>                                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Category : skforecast.exceptions.InputTypeWarning                                    <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Location :                                                                           <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\utils\\u <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> tils.py:2349                                                                         <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Suppress : warnings.simplefilter('ignore', category=InputTypeWarning)                <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╰──────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[38;5;214m╭─\u001b[0m\u001b[38;5;214m─────────────────────────────────\u001b[0m\u001b[38;5;214m InputTypeWarning \u001b[0m\u001b[38;5;214m─────────────────────────────────\u001b[0m\u001b[38;5;214m─╮\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Passing a DataFrame (either wide or long format) as `series` requires additional     \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m internal transformations, which can increase computational time. It is recommended   \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m to use a dictionary of pandas Series instead. For more details, see:                 \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m https://skforecast.org/latest/user_guides/independent-multi-time-series-forecasting. \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m html#input-data                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m                                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Category : skforecast.exceptions.InputTypeWarning                                    \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Location :                                                                           \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\utils\\u \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m tils.py:2349                                                                         \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Suppress : warnings.simplefilter('ignore', category=InputTypeWarning)                \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m╰──────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <style>\n",
       "        .container-29297d2af35d46abb9fadd4e2aca331e {\n",
       "            font-family: 'Arial', sans-serif;\n",
       "            font-size: 0.9em;\n",
       "            color: #333333;\n",
       "            border: 1px solid #ddd;\n",
       "            background-color: #f0f8ff;\n",
       "            padding: 5px 15px;\n",
       "            border-radius: 8px;\n",
       "            max-width: 600px;\n",
       "            #margin: auto;\n",
       "        }\n",
       "        .container-29297d2af35d46abb9fadd4e2aca331e h2 {\n",
       "            font-size: 1.5em;\n",
       "            color: #222222;\n",
       "            border-bottom: 2px solid #ddd;\n",
       "            padding-bottom: 5px;\n",
       "            margin-bottom: 15px;\n",
       "            margin-top: 5px;\n",
       "        }\n",
       "        .container-29297d2af35d46abb9fadd4e2aca331e details {\n",
       "            margin: 10px 0;\n",
       "        }\n",
       "        .container-29297d2af35d46abb9fadd4e2aca331e summary {\n",
       "            font-weight: bold;\n",
       "            font-size: 1.1em;\n",
       "            color: #000000;\n",
       "            cursor: pointer;\n",
       "            margin-bottom: 5px;\n",
       "            background-color: #b3dbfd;\n",
       "            padding: 5px;\n",
       "            border-radius: 5px;\n",
       "        }\n",
       "        .container-29297d2af35d46abb9fadd4e2aca331e summary:hover {\n",
       "            color: #000000;\n",
       "            background-color: #e0e0e0;\n",
       "        }\n",
       "        .container-29297d2af35d46abb9fadd4e2aca331e ul {\n",
       "            font-family: 'Courier New', monospace;\n",
       "            list-style-type: none;\n",
       "            padding-left: 20px;\n",
       "            margin: 10px 0;\n",
       "            line-height: normal;\n",
       "        }\n",
       "        .container-29297d2af35d46abb9fadd4e2aca331e li {\n",
       "            margin: 5px 0;\n",
       "            font-family: 'Courier New', monospace;\n",
       "        }\n",
       "        .container-29297d2af35d46abb9fadd4e2aca331e li strong {\n",
       "            font-weight: bold;\n",
       "            color: #444444;\n",
       "        }\n",
       "        .container-29297d2af35d46abb9fadd4e2aca331e li::before {\n",
       "            content: \"- \";\n",
       "            color: #666666;\n",
       "        }\n",
       "        .container-29297d2af35d46abb9fadd4e2aca331e a {\n",
       "            color: #001633;\n",
       "            text-decoration: none;\n",
       "        }\n",
       "        .container-29297d2af35d46abb9fadd4e2aca331e a:hover {\n",
       "            color: #359ccb; \n",
       "        }\n",
       "    </style>\n",
       "    \n",
       "        <div class=\"container-29297d2af35d46abb9fadd4e2aca331e\">\n",
       "            <p style=\"font-size: 1.5em; font-weight: bold; margin-block-start: 0.83em; margin-block-end: 0.83em;\">ForecasterRecursiveMultiSeries</p>\n",
       "            <details open>\n",
       "                <summary>General Information</summary>\n",
       "                <ul>\n",
       "                    <li><strong>Estimator:</strong> LGBMRegressor</li>\n",
       "                    <li><strong>Lags:</strong> [1 2 3 4 5]</li>\n",
       "                    <li><strong>Window features:</strong> ['roll_mean_5', 'roll_sum_5']</li>\n",
       "                    <li><strong>Window size:</strong> 5</li>\n",
       "                    <li><strong>Series encoding:</strong> ordinal</li>\n",
       "                    <li><strong>Exogenous included:</strong> False</li>\n",
       "                    <li><strong>Weight function included:</strong> False</li>\n",
       "                    <li><strong>Series weights:</strong> None</li>\n",
       "                    <li><strong>Differentiation order:</strong> None</li>\n",
       "                    <li><strong>Creation date:</strong> 2025-11-27 12:06:14</li>\n",
       "                    <li><strong>Last fit date:</strong> 2025-11-27 12:06:15</li>\n",
       "                    <li><strong>Skforecast version:</strong> 0.19.0</li>\n",
       "                    <li><strong>Python version:</strong> 3.12.11</li>\n",
       "                    <li><strong>Forecaster id:</strong> None</li>\n",
       "                </ul>\n",
       "            </details>\n",
       "            <details>\n",
       "                <summary>Exogenous Variables</summary>\n",
       "                <ul>\n",
       "                    None\n",
       "                </ul>\n",
       "            </details>\n",
       "            <details>\n",
       "                <summary>Data Transformations</summary>\n",
       "                <ul>\n",
       "                    <li><strong>Transformer for series:</strong> None</li>\n",
       "                    <li><strong>Transformer for exog:</strong> None</li>\n",
       "                </ul>\n",
       "            </details>\n",
       "            <details>\n",
       "                <summary>Training Information</summary>\n",
       "                <ul>\n",
       "                    <li><strong>Series names (levels):</strong> item_1, item_2, item_3</li>\n",
       "                    <li><strong>Training range:</strong> 'item_1': ['2012-01-01', '2015-01-01'], 'item_2': ['2012-01-01', '2015-01-01'], 'item_3': ['2012-01-01', '2015-01-01']</li>\n",
       "                    <li><strong>Training index type:</strong> DatetimeIndex</li>\n",
       "                    <li><strong>Training index frequency:</strong> <Day></li>\n",
       "                </ul>\n",
       "            </details>\n",
       "            <details>\n",
       "                <summary>Estimator Parameters</summary>\n",
       "                <ul>\n",
       "                    {'boosting_type': 'gbdt', 'class_weight': None, 'colsample_bytree': 1.0, 'importance_type': 'split', 'learning_rate': 0.1, 'max_depth': -1, 'min_child_samples': 20, 'min_child_weight': 0.001, 'min_split_gain': 0.0, 'n_estimators': 100, 'n_jobs': None, 'num_leaves': 31, 'objective': None, 'random_state': 123, 'reg_alpha': 0.0, 'reg_lambda': 0.0, 'subsample': 1.0, 'subsample_for_bin': 200000, 'subsample_freq': 0, 'verbose': -1}\n",
       "                </ul>\n",
       "            </details>\n",
       "            <details>\n",
       "                <summary>Fit Kwargs</summary>\n",
       "                <ul>\n",
       "                    {}\n",
       "                </ul>\n",
       "            </details>\n",
       "            <p>\n",
       "                <a href=\"https://skforecast.org/0.19.0/api/forecasterrecursivemultiseries.html\">&#128712 <strong>API Reference</strong></a>\n",
       "                &nbsp;&nbsp;\n",
       "                <a href=\"https://skforecast.org/0.19.0/user_guides/independent-multi-time-series-forecasting.html\">&#128462 <strong>User Guide</strong></a>\n",
       "            </p>\n",
       "        </div>\n",
       "        "
      ],
      "text/plain": [
       "============================== \n",
       "ForecasterRecursiveMultiSeries \n",
       "============================== \n",
       "Estimator: LGBMRegressor \n",
       "Lags: [1 2 3 4 5] \n",
       "Window features: ['roll_mean_5', 'roll_sum_5'] \n",
       "Window size: 5 \n",
       "Series encoding: ordinal \n",
       "Series names (levels): item_1, item_2, item_3 \n",
       "Exogenous included: False \n",
       "Exogenous names: None \n",
       "Transformer for series: None \n",
       "Transformer for exog: None \n",
       "Weight function included: False \n",
       "Series weights: None \n",
       "Differentiation order: None \n",
       "Training range: \n",
       "    'item_1': ['2012-01-01', '2015-01-01'], 'item_2': ['2012-01-01', '2015-01-01'],\n",
       "    'item_3': ['2012-01-01', '2015-01-01'] \n",
       "Training index type: DatetimeIndex \n",
       "Training index frequency: <Day> \n",
       "Estimator parameters: \n",
       "    {'boosting_type': 'gbdt', 'class_weight': None, 'colsample_bytree': 1.0,\n",
       "    'importance_type': 'split', 'learning_rate': 0.1, 'max_depth': -1,\n",
       "    'min_child_samples': 20, 'min_child_weight': 0.001, 'min_split_gain': 0.0,\n",
       "    'n_estimators': 100, 'n_jobs': None, 'num_leaves': 31, 'objective': None,\n",
       "    'random_state': 123, 'reg_alpha': 0.0, 'reg_lambda': 0.0, 'subsample': 1.0,\n",
       "    'subsample_for_bin': 200000, 'subsample_freq': 0, 'verbose': -1} \n",
       "fit_kwargs: {} \n",
       "Creation date: 2025-11-27 12:06:14 \n",
       "Last fit date: 2025-11-27 12:06:15 \n",
       "Skforecast version: 0.19.0 \n",
       "Python version: 3.12.11 \n",
       "Forecaster id: None "
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create and fit forecaster\n",
    "# ==============================================================================\n",
    "window_features = RollingFeatures(\n",
    "                      stats        = ['mean', 'sum'],\n",
    "                      window_sizes = [5, 5]\n",
    "                  )\n",
    "\n",
    "forecaster = ForecasterRecursiveMultiSeries(\n",
    "                 estimator       = LGBMRegressor(random_state=123, verbose=-1),\n",
    "                 lags            = 5,\n",
    "                 window_features = window_features,\n",
    "                 encoding        = 'ordinal'\n",
    "             )\n",
    "\n",
    "forecaster.fit(series=data_multiseries)\n",
    "forecaster"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╭────────────────────────────────── InputTypeWarning ──────────────────────────────────╮</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Passing a DataFrame (either wide or long format) as `series` requires additional     <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> internal transformations, which can increase computational time. It is recommended   <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> to use a dictionary of pandas Series instead. For more details, see:                 <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> https://skforecast.org/latest/user_guides/independent-multi-time-series-forecasting. <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> html#input-data                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>                                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Category : skforecast.exceptions.InputTypeWarning                                    <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Location :                                                                           <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\utils\\u <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> tils.py:2349                                                                         <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Suppress : warnings.simplefilter('ignore', category=InputTypeWarning)                <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╰──────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[38;5;214m╭─\u001b[0m\u001b[38;5;214m─────────────────────────────────\u001b[0m\u001b[38;5;214m InputTypeWarning \u001b[0m\u001b[38;5;214m─────────────────────────────────\u001b[0m\u001b[38;5;214m─╮\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Passing a DataFrame (either wide or long format) as `series` requires additional     \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m internal transformations, which can increase computational time. It is recommended   \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m to use a dictionary of pandas Series instead. For more details, see:                 \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m https://skforecast.org/latest/user_guides/independent-multi-time-series-forecasting. \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m html#input-data                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m                                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Category : skforecast.exceptions.InputTypeWarning                                    \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Location :                                                                           \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\utils\\u \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m tils.py:2349                                                                         \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Suppress : warnings.simplefilter('ignore', category=InputTypeWarning)                \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m╰──────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create training matrices\n",
    "# ==============================================================================\n",
    "X_train, y_train = forecaster.create_train_X_y(series=data_multiseries)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Depending on the [series encoding](../user_guides/independent-multi-time-series-forecasting.html#series-encoding-in-multi-series) selected, the column(s) generated to identify the series to which the observations belong may be different. In this case, the column `_level_skforecast` is generated as `encoding = 'ordinal'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>lag_1</th>\n",
       "      <th>lag_2</th>\n",
       "      <th>lag_3</th>\n",
       "      <th>lag_4</th>\n",
       "      <th>lag_5</th>\n",
       "      <th>roll_mean_5</th>\n",
       "      <th>roll_sum_5</th>\n",
       "      <th>_level_skforecast</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2012-01-06</th>\n",
       "      <td>21.379238</td>\n",
       "      <td>25.895533</td>\n",
       "      <td>27.549099</td>\n",
       "      <td>22.777826</td>\n",
       "      <td>8.253175</td>\n",
       "      <td>21.170974</td>\n",
       "      <td>105.854870</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-01-07</th>\n",
       "      <td>21.106643</td>\n",
       "      <td>21.379238</td>\n",
       "      <td>25.895533</td>\n",
       "      <td>27.549099</td>\n",
       "      <td>22.777826</td>\n",
       "      <td>23.741668</td>\n",
       "      <td>118.708338</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-01-08</th>\n",
       "      <td>20.533871</td>\n",
       "      <td>21.106643</td>\n",
       "      <td>21.379238</td>\n",
       "      <td>25.895533</td>\n",
       "      <td>27.549099</td>\n",
       "      <td>23.292877</td>\n",
       "      <td>116.464384</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                lag_1      lag_2      lag_3      lag_4      lag_5  \\\n",
       "2012-01-06  21.379238  25.895533  27.549099  22.777826   8.253175   \n",
       "2012-01-07  21.106643  21.379238  25.895533  27.549099  22.777826   \n",
       "2012-01-08  20.533871  21.106643  21.379238  25.895533  27.549099   \n",
       "\n",
       "            roll_mean_5  roll_sum_5  _level_skforecast  \n",
       "2012-01-06    21.170974  105.854870                  0  \n",
       "2012-01-07    23.741668  118.708338                  0  \n",
       "2012-01-08    23.292877  116.464384                  0  "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Predictors matrix\n",
    "# ==============================================================================\n",
    "X_train.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2012-01-06    21.106643\n",
       "2012-01-07    20.533871\n",
       "2012-01-08    20.069327\n",
       "Name: y, dtype: float64"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Target variable matrix\n",
    "# ==============================================================================\n",
    "y_train.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can obtain the training predictions using the `predict` method of the estimator stored inside the forecaster object. By examining the predictions on the training data, analysts can get a better understanding of how the model is performing and make adjustments as necessary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([19.54628549, 22.29989602, 20.10135048, 20.97563208])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Training predictions using the internal estimator\n",
    "# ==============================================================================\n",
    "predictions_training = forecaster.estimator.predict(X_train)\n",
    "predictions_training[:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Skforecast provides the `create_predict_X` method to generate the matrices that the forecaster is using to make predictions. This method can be used to gain insight into the specific data manipulations that occur during the prediction process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>level</th>\n",
       "      <th>lag_1</th>\n",
       "      <th>lag_2</th>\n",
       "      <th>lag_3</th>\n",
       "      <th>lag_4</th>\n",
       "      <th>lag_5</th>\n",
       "      <th>roll_mean_5</th>\n",
       "      <th>roll_sum_5</th>\n",
       "      <th>_level_skforecast</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2015-01-02</th>\n",
       "      <td>item_1</td>\n",
       "      <td>10.496302</td>\n",
       "      <td>18.721223</td>\n",
       "      <td>18.857026</td>\n",
       "      <td>19.611623</td>\n",
       "      <td>17.329233</td>\n",
       "      <td>17.003081</td>\n",
       "      <td>85.015406</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2015-01-03</th>\n",
       "      <td>item_1</td>\n",
       "      <td>13.614696</td>\n",
       "      <td>10.496302</td>\n",
       "      <td>18.721223</td>\n",
       "      <td>18.857026</td>\n",
       "      <td>19.611623</td>\n",
       "      <td>16.260174</td>\n",
       "      <td>81.300869</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2015-01-04</th>\n",
       "      <td>item_1</td>\n",
       "      <td>14.526244</td>\n",
       "      <td>13.614696</td>\n",
       "      <td>10.496302</td>\n",
       "      <td>18.721223</td>\n",
       "      <td>18.857026</td>\n",
       "      <td>15.243098</td>\n",
       "      <td>76.215490</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2015-01-05</th>\n",
       "      <td>item_1</td>\n",
       "      <td>16.802037</td>\n",
       "      <td>14.526244</td>\n",
       "      <td>13.614696</td>\n",
       "      <td>10.496302</td>\n",
       "      <td>18.721223</td>\n",
       "      <td>14.832100</td>\n",
       "      <td>74.160501</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2015-01-06</th>\n",
       "      <td>item_1</td>\n",
       "      <td>13.888023</td>\n",
       "      <td>16.802037</td>\n",
       "      <td>14.526244</td>\n",
       "      <td>13.614696</td>\n",
       "      <td>10.496302</td>\n",
       "      <td>13.865460</td>\n",
       "      <td>69.327302</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             level      lag_1      lag_2      lag_3      lag_4      lag_5  \\\n",
       "2015-01-02  item_1  10.496302  18.721223  18.857026  19.611623  17.329233   \n",
       "2015-01-03  item_1  13.614696  10.496302  18.721223  18.857026  19.611623   \n",
       "2015-01-04  item_1  14.526244  13.614696  10.496302  18.721223  18.857026   \n",
       "2015-01-05  item_1  16.802037  14.526244  13.614696  10.496302  18.721223   \n",
       "2015-01-06  item_1  13.888023  16.802037  14.526244  13.614696  10.496302   \n",
       "\n",
       "            roll_mean_5  roll_sum_5  _level_skforecast  \n",
       "2015-01-02    17.003081   85.015406                0.0  \n",
       "2015-01-03    16.260174   81.300869                0.0  \n",
       "2015-01-04    15.243098   76.215490                0.0  \n",
       "2015-01-05    14.832100   74.160501                0.0  \n",
       "2015-01-06    13.865460   69.327302                0.0  "
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create input matrix for predict method\n",
    "# ==============================================================================\n",
    "X_predict_dict = forecaster.create_predict_X(steps=5, levels=None)  # All levels\n",
    "\n",
    "# Check 'item_1' matrix\n",
    "X_predict_item_1 = X_predict_dict.query('level == \"item_1\"')\n",
    "X_predict_item_1.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([13.61469596, 14.5262436 , 16.80203691, 13.88802319, 15.13547167])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Predict 'item_1' using the internal estimator\n",
    "# ==============================================================================\n",
    "predictions_item_1 = forecaster.estimator.predict(X_predict_item_1.drop(columns='level'))\n",
    "predictions_item_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ForecasterDirectMultiVariate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>so2</th>\n",
       "      <th>co</th>\n",
       "      <th>no</th>\n",
       "      <th>no2</th>\n",
       "      <th>pm10</th>\n",
       "      <th>nox</th>\n",
       "      <th>o3</th>\n",
       "      <th>veloc.</th>\n",
       "      <th>direc.</th>\n",
       "      <th>pm2.5</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>datetime</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2019-01-01 00:00:00</th>\n",
       "      <td>8.0</td>\n",
       "      <td>0.2</td>\n",
       "      <td>3.0</td>\n",
       "      <td>36.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>16.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>262.0</td>\n",
       "      <td>19.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-01-01 01:00:00</th>\n",
       "      <td>8.0</td>\n",
       "      <td>0.1</td>\n",
       "      <td>2.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>32.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>0.6</td>\n",
       "      <td>248.0</td>\n",
       "      <td>26.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-01-01 02:00:00</th>\n",
       "      <td>8.0</td>\n",
       "      <td>0.1</td>\n",
       "      <td>11.0</td>\n",
       "      <td>42.0</td>\n",
       "      <td>36.0</td>\n",
       "      <td>58.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.3</td>\n",
       "      <td>224.0</td>\n",
       "      <td>31.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     so2   co    no   no2  pm10   nox    o3  veloc.  direc.  \\\n",
       "datetime                                                                      \n",
       "2019-01-01 00:00:00  8.0  0.2   3.0  36.0  22.0  40.0  16.0     0.5   262.0   \n",
       "2019-01-01 01:00:00  8.0  0.1   2.0  40.0  32.0  44.0   6.0     0.6   248.0   \n",
       "2019-01-01 02:00:00  8.0  0.1  11.0  42.0  36.0  58.0   3.0     0.3   224.0   \n",
       "\n",
       "                     pm2.5  \n",
       "datetime                    \n",
       "2019-01-01 00:00:00   19.0  \n",
       "2019-01-01 01:00:00   26.0  \n",
       "2019-01-01 02:00:00   31.0  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Data\n",
    "# ==============================================================================\n",
    "display(data_multivariate.head(3))\n",
    "\n",
    "# Plot\n",
    "# ==============================================================================\n",
    "fig, axes = plt.subplots(nrows=3, ncols=1, figsize=(9, 4), sharex=True)\n",
    "\n",
    "for i, col in enumerate(data_multivariate.columns[:3]):\n",
    "    data_multivariate[col].plot(ax=axes[i])\n",
    "    axes[i].set_xlabel('')\n",
    "    axes[i].set_ylabel('sales')\n",
    "    axes[i].set_title(col)\n",
    "\n",
    "fig.tight_layout()\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <style>\n",
       "        .container-68dd4a949cfa42b388e235827210117c {\n",
       "            font-family: 'Arial', sans-serif;\n",
       "            font-size: 0.9em;\n",
       "            color: #333333;\n",
       "            border: 1px solid #ddd;\n",
       "            background-color: #f0f8ff;\n",
       "            padding: 5px 15px;\n",
       "            border-radius: 8px;\n",
       "            max-width: 600px;\n",
       "            #margin: auto;\n",
       "        }\n",
       "        .container-68dd4a949cfa42b388e235827210117c h2 {\n",
       "            font-size: 1.5em;\n",
       "            color: #222222;\n",
       "            border-bottom: 2px solid #ddd;\n",
       "            padding-bottom: 5px;\n",
       "            margin-bottom: 15px;\n",
       "            margin-top: 5px;\n",
       "        }\n",
       "        .container-68dd4a949cfa42b388e235827210117c details {\n",
       "            margin: 10px 0;\n",
       "        }\n",
       "        .container-68dd4a949cfa42b388e235827210117c summary {\n",
       "            font-weight: bold;\n",
       "            font-size: 1.1em;\n",
       "            color: #000000;\n",
       "            cursor: pointer;\n",
       "            margin-bottom: 5px;\n",
       "            background-color: #b3dbfd;\n",
       "            padding: 5px;\n",
       "            border-radius: 5px;\n",
       "        }\n",
       "        .container-68dd4a949cfa42b388e235827210117c summary:hover {\n",
       "            color: #000000;\n",
       "            background-color: #e0e0e0;\n",
       "        }\n",
       "        .container-68dd4a949cfa42b388e235827210117c ul {\n",
       "            font-family: 'Courier New', monospace;\n",
       "            list-style-type: none;\n",
       "            padding-left: 20px;\n",
       "            margin: 10px 0;\n",
       "            line-height: normal;\n",
       "        }\n",
       "        .container-68dd4a949cfa42b388e235827210117c li {\n",
       "            margin: 5px 0;\n",
       "            font-family: 'Courier New', monospace;\n",
       "        }\n",
       "        .container-68dd4a949cfa42b388e235827210117c li strong {\n",
       "            font-weight: bold;\n",
       "            color: #444444;\n",
       "        }\n",
       "        .container-68dd4a949cfa42b388e235827210117c li::before {\n",
       "            content: \"- \";\n",
       "            color: #666666;\n",
       "        }\n",
       "        .container-68dd4a949cfa42b388e235827210117c a {\n",
       "            color: #001633;\n",
       "            text-decoration: none;\n",
       "        }\n",
       "        .container-68dd4a949cfa42b388e235827210117c a:hover {\n",
       "            color: #359ccb; \n",
       "        }\n",
       "    </style>\n",
       "    \n",
       "        <div class=\"container-68dd4a949cfa42b388e235827210117c\">\n",
       "            <p style=\"font-size: 1.5em; font-weight: bold; margin-block-start: 0.83em; margin-block-end: 0.83em;\">ForecasterDirectMultiVariate</p>\n",
       "            <details open>\n",
       "                <summary>General Information</summary>\n",
       "                <ul>\n",
       "                    <li><strong>Estimator:</strong> Ridge</li>\n",
       "                    <li><strong>Target series (level):</strong> co</li>\n",
       "                    <li><strong>Lags:</strong> [1 2 3]</li>\n",
       "                    <li><strong>Window features:</strong> ['roll_mean_5', 'roll_sum_5']</li>\n",
       "                    <li><strong>Window size:</strong> 5</li>\n",
       "                    <li><strong>Maximum steps to predict:</strong> 3</li>\n",
       "                    <li><strong>Exogenous included:</strong> False</li>\n",
       "                    <li><strong>Weight function included:</strong> False</li>\n",
       "                    <li><strong>Differentiation order:</strong> None</li>\n",
       "                    <li><strong>Creation date:</strong> 2025-11-27 12:06:16</li>\n",
       "                    <li><strong>Last fit date:</strong> 2025-11-27 12:06:16</li>\n",
       "                    <li><strong>Skforecast version:</strong> 0.19.0</li>\n",
       "                    <li><strong>Python version:</strong> 3.12.11</li>\n",
       "                    <li><strong>Forecaster id:</strong> None</li>\n",
       "                </ul>\n",
       "            </details>\n",
       "            <details>\n",
       "                <summary>Exogenous Variables</summary>\n",
       "                <ul>\n",
       "                    None\n",
       "                </ul>\n",
       "            </details>\n",
       "            <details>\n",
       "                <summary>Data Transformations</summary>\n",
       "                <ul>\n",
       "                    <li><strong>Transformer for series:</strong> StandardScaler()</li>\n",
       "                    <li><strong>Transformer for exog:</strong> None</li>\n",
       "                </ul>\n",
       "            </details>\n",
       "            <details>\n",
       "                <summary>Training Information</summary>\n",
       "                <ul>\n",
       "                    <li><strong>Target series (level):</strong> co</li>\n",
       "                    <li><strong>Multivariate series:</strong> so2, co, no, no2, pm10, nox, o3, veloc., direc., pm2.5</li>\n",
       "                    <li><strong>Training range:</strong> [Timestamp('2019-01-01 00:00:00'), Timestamp('2023-12-31 23:00:00')]</li>\n",
       "                    <li><strong>Training index type:</strong> DatetimeIndex</li>\n",
       "                    <li><strong>Training index frequency:</strong> <Hour></li>\n",
       "                </ul>\n",
       "            </details>\n",
       "            <details>\n",
       "                <summary>Estimator Parameters</summary>\n",
       "                <ul>\n",
       "                    {'alpha': 1.0, 'copy_X': True, 'fit_intercept': True, 'max_iter': None, 'positive': False, 'random_state': 123, 'solver': 'auto', 'tol': 0.0001}\n",
       "                </ul>\n",
       "            </details>\n",
       "            <details>\n",
       "                <summary>Fit Kwargs</summary>\n",
       "                <ul>\n",
       "                    {}\n",
       "                </ul>\n",
       "            </details>\n",
       "            <p>\n",
       "                <a href=\"https://skforecast.org/0.19.0/api/forecasterdirectmultivariate.html\">&#128712 <strong>API Reference</strong></a>\n",
       "                &nbsp;&nbsp;\n",
       "                <a href=\"https://skforecast.org/0.19.0/user_guides/dependent-multi-series-multivariate-forecasting.html\">&#128462 <strong>User Guide</strong></a>\n",
       "            </p>\n",
       "        </div>\n",
       "        "
      ],
      "text/plain": [
       "============================ \n",
       "ForecasterDirectMultiVariate \n",
       "============================ \n",
       "Estimator: Ridge \n",
       "Target series (level): co \n",
       "Lags: [1 2 3] \n",
       "Window features: ['roll_mean_5', 'roll_sum_5'] \n",
       "Window size: 5 \n",
       "Maximum steps to predict: 3 \n",
       "Multivariate series: so2, co, no, no2, pm10, nox, o3, veloc., direc., pm2.5 \n",
       "Exogenous included: False \n",
       "Exogenous names: None \n",
       "Transformer for series: StandardScaler() \n",
       "Transformer for exog: None \n",
       "Weight function included: False \n",
       "Differentiation order: None \n",
       "Training range: [Timestamp('2019-01-01 00:00:00'), Timestamp('2023-12-31 23:00:00')] \n",
       "Training index type: DatetimeIndex \n",
       "Training index frequency: <Hour> \n",
       "Estimator parameters: \n",
       "    {'alpha': 1.0, 'copy_X': True, 'fit_intercept': True, 'max_iter': None,\n",
       "    'positive': False, 'random_state': 123, 'solver': 'auto', 'tol': 0.0001} \n",
       "fit_kwargs: {} \n",
       "Creation date: 2025-11-27 12:06:16 \n",
       "Last fit date: 2025-11-27 12:06:16 \n",
       "Skforecast version: 0.19.0 \n",
       "Python version: 3.12.11 \n",
       "Forecaster id: None "
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create and fit forecaster\n",
    "# ==============================================================================\n",
    "window_features = RollingFeatures(\n",
    "                      stats        = ['mean', 'sum'],\n",
    "                      window_sizes = [5, 5]\n",
    "                  )\n",
    "\n",
    "forecaster = ForecasterDirectMultiVariate(\n",
    "                 estimator       = Ridge(random_state=123),\n",
    "                 level           = 'co',\n",
    "                 steps           = 3,\n",
    "                 lags            = 3,\n",
    "                 window_features = window_features\n",
    "             )\n",
    "\n",
    "forecaster.fit(series=data_multivariate)\n",
    "forecaster"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Columns : ['so2_lag_1', 'so2_lag_2', 'so2_lag_3', 'so2_roll_mean_5', 'so2_roll_sum_5', 'co_lag_1', 'co_lag_2', 'co_lag_3', 'co_roll_mean_5', 'co_roll_sum_5', 'no_lag_1', 'no_lag_2', 'no_lag_3', 'no_roll_mean_5', 'no_roll_sum_5', 'no2_lag_1', 'no2_lag_2', 'no2_lag_3', 'no2_roll_mean_5', 'no2_roll_sum_5', 'pm10_lag_1', 'pm10_lag_2', 'pm10_lag_3', 'pm10_roll_mean_5', 'pm10_roll_sum_5', 'nox_lag_1', 'nox_lag_2', 'nox_lag_3', 'nox_roll_mean_5', 'nox_roll_sum_5', 'o3_lag_1', 'o3_lag_2', 'o3_lag_3', 'o3_roll_mean_5', 'o3_roll_sum_5', 'veloc._lag_1', 'veloc._lag_2', 'veloc._lag_3', 'veloc._roll_mean_5', 'veloc._roll_sum_5', 'direc._lag_1', 'direc._lag_2', 'direc._lag_3', 'direc._roll_mean_5', 'direc._roll_sum_5', 'pm2.5_lag_1', 'pm2.5_lag_2', 'pm2.5_lag_3', 'pm2.5_roll_mean_5', 'pm2.5_roll_sum_5']\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>so2_lag_1</th>\n",
       "      <th>so2_lag_2</th>\n",
       "      <th>so2_lag_3</th>\n",
       "      <th>so2_roll_mean_5</th>\n",
       "      <th>so2_roll_sum_5</th>\n",
       "      <th>co_lag_1</th>\n",
       "      <th>co_lag_2</th>\n",
       "      <th>co_lag_3</th>\n",
       "      <th>co_roll_mean_5</th>\n",
       "      <th>co_roll_sum_5</th>\n",
       "      <th>...</th>\n",
       "      <th>direc._lag_1</th>\n",
       "      <th>direc._lag_2</th>\n",
       "      <th>direc._lag_3</th>\n",
       "      <th>direc._roll_mean_5</th>\n",
       "      <th>direc._roll_sum_5</th>\n",
       "      <th>pm2.5_lag_1</th>\n",
       "      <th>pm2.5_lag_2</th>\n",
       "      <th>pm2.5_lag_3</th>\n",
       "      <th>pm2.5_roll_mean_5</th>\n",
       "      <th>pm2.5_roll_sum_5</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>datetime</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2019-01-01 05:00:00</th>\n",
       "      <td>5.777693</td>\n",
       "      <td>4.969880</td>\n",
       "      <td>3.354255</td>\n",
       "      <td>4.162068</td>\n",
       "      <td>20.810338</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-0.125168</td>\n",
       "      <td>-0.625841</td>\n",
       "      <td>...</td>\n",
       "      <td>0.538214</td>\n",
       "      <td>0.528519</td>\n",
       "      <td>0.567299</td>\n",
       "      <td>0.673943</td>\n",
       "      <td>3.369715</td>\n",
       "      <td>2.493131</td>\n",
       "      <td>2.493131</td>\n",
       "      <td>2.613291</td>\n",
       "      <td>2.156683</td>\n",
       "      <td>10.783416</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-01-01 06:00:00</th>\n",
       "      <td>4.969880</td>\n",
       "      <td>5.777693</td>\n",
       "      <td>4.969880</td>\n",
       "      <td>4.485193</td>\n",
       "      <td>22.425964</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-2.239803</td>\n",
       "      <td>...</td>\n",
       "      <td>0.644858</td>\n",
       "      <td>0.538214</td>\n",
       "      <td>0.528519</td>\n",
       "      <td>0.615774</td>\n",
       "      <td>3.078868</td>\n",
       "      <td>1.772172</td>\n",
       "      <td>2.493131</td>\n",
       "      <td>2.493131</td>\n",
       "      <td>2.276843</td>\n",
       "      <td>11.384215</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-01-01 07:00:00</th>\n",
       "      <td>4.969880</td>\n",
       "      <td>4.969880</td>\n",
       "      <td>5.777693</td>\n",
       "      <td>4.808318</td>\n",
       "      <td>24.041589</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-2.239803</td>\n",
       "      <td>...</td>\n",
       "      <td>0.751502</td>\n",
       "      <td>0.644858</td>\n",
       "      <td>0.538214</td>\n",
       "      <td>0.606079</td>\n",
       "      <td>3.030393</td>\n",
       "      <td>0.570573</td>\n",
       "      <td>1.772172</td>\n",
       "      <td>2.493131</td>\n",
       "      <td>1.988459</td>\n",
       "      <td>9.942297</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>3 rows × 50 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                     so2_lag_1  so2_lag_2  so2_lag_3  so2_roll_mean_5  \\\n",
       "datetime                                                                \n",
       "2019-01-01 05:00:00   5.777693   4.969880   3.354255         4.162068   \n",
       "2019-01-01 06:00:00   4.969880   5.777693   4.969880         4.485193   \n",
       "2019-01-01 07:00:00   4.969880   4.969880   5.777693         4.808318   \n",
       "\n",
       "                     so2_roll_sum_5  co_lag_1  co_lag_2  co_lag_3  \\\n",
       "datetime                                                            \n",
       "2019-01-01 05:00:00       20.810338 -0.447961 -0.447961 -0.447961   \n",
       "2019-01-01 06:00:00       22.425964 -0.447961 -0.447961 -0.447961   \n",
       "2019-01-01 07:00:00       24.041589 -0.447961 -0.447961 -0.447961   \n",
       "\n",
       "                     co_roll_mean_5  co_roll_sum_5  ...  direc._lag_1  \\\n",
       "datetime                                            ...                 \n",
       "2019-01-01 05:00:00       -0.125168      -0.625841  ...      0.538214   \n",
       "2019-01-01 06:00:00       -0.447961      -2.239803  ...      0.644858   \n",
       "2019-01-01 07:00:00       -0.447961      -2.239803  ...      0.751502   \n",
       "\n",
       "                     direc._lag_2  direc._lag_3  direc._roll_mean_5  \\\n",
       "datetime                                                              \n",
       "2019-01-01 05:00:00      0.528519      0.567299            0.673943   \n",
       "2019-01-01 06:00:00      0.538214      0.528519            0.615774   \n",
       "2019-01-01 07:00:00      0.644858      0.538214            0.606079   \n",
       "\n",
       "                     direc._roll_sum_5  pm2.5_lag_1  pm2.5_lag_2  pm2.5_lag_3  \\\n",
       "datetime                                                                        \n",
       "2019-01-01 05:00:00           3.369715     2.493131     2.493131     2.613291   \n",
       "2019-01-01 06:00:00           3.078868     1.772172     2.493131     2.493131   \n",
       "2019-01-01 07:00:00           3.030393     0.570573     1.772172     2.493131   \n",
       "\n",
       "                     pm2.5_roll_mean_5  pm2.5_roll_sum_5  \n",
       "datetime                                                  \n",
       "2019-01-01 05:00:00           2.156683         10.783416  \n",
       "2019-01-01 06:00:00           2.276843         11.384215  \n",
       "2019-01-01 07:00:00           1.988459          9.942297  \n",
       "\n",
       "[3 rows x 50 columns]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create the whole train matrix\n",
    "# ==============================================================================\n",
    "X_train, y_train = forecaster.create_train_X_y(series=data_multivariate)\n",
    "\n",
    "# Extract X and y for step 1\n",
    "X_train_1, y_train_1 = forecaster.filter_train_X_y_for_step(\n",
    "                           step          = 1,\n",
    "                           X_train       = X_train,\n",
    "                           y_train       = y_train,\n",
    "                           remove_suffix = False\n",
    "                       )\n",
    "\n",
    "print(\"Columns :\", list(X_train_1.columns))\n",
    "X_train_1.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime\n",
       "2019-01-01 05:00:00   -0.447961\n",
       "2019-01-01 06:00:00   -0.447961\n",
       "2019-01-01 07:00:00   -0.447961\n",
       "Freq: h, Name: co_step_1, dtype: float64"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Target variable matrix for step 1\n",
    "# ==============================================================================\n",
    "y_train_1.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{np.int64(1): Ridge(random_state=123),\n",
       " np.int64(2): Ridge(random_state=123),\n",
       " np.int64(3): Ridge(random_state=123)}"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Internal estimators {step: estimator}\n",
    "# ==============================================================================\n",
    "forecaster.estimators_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.33195755, -0.41491613, -0.42473316, -0.26854783])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Step 1 training predictions using the internal estimator\n",
    "# ==============================================================================\n",
    "predictions_training = forecaster.estimators_[1].predict(X_train_1)\n",
    "predictions_training[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╭───────────────────────────── DataTransformationWarning ──────────────────────────────╮</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> The output matrix is in the transformed scale due to the inclusion of                <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> transformations or differentiation in the Forecaster. As a result, any predictions   <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> generated using this matrix will also be in the transformed scale. Please refer to   <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> the documentation for more details:                                                  <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> https://skforecast.org/latest/user_guides/training-and-prediction-matrices.html      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>                                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Category : skforecast.exceptions.DataTransformationWarning                           <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Location :                                                                           <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\direct\\ <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> _forecaster_direct_multivariate.py:1994                                              <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Suppress : warnings.simplefilter('ignore', category=DataTransformationWarning)       <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╰──────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[38;5;214m╭─\u001b[0m\u001b[38;5;214m────────────────────────────\u001b[0m\u001b[38;5;214m DataTransformationWarning \u001b[0m\u001b[38;5;214m─────────────────────────────\u001b[0m\u001b[38;5;214m─╮\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m The output matrix is in the transformed scale due to the inclusion of                \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m transformations or differentiation in the Forecaster. As a result, any predictions   \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m generated using this matrix will also be in the transformed scale. Please refer to   \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m the documentation for more details:                                                  \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m https://skforecast.org/latest/user_guides/training-and-prediction-matrices.html      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m                                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Category : skforecast.exceptions.DataTransformationWarning                           \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Location :                                                                           \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\direct\\ \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m _forecaster_direct_multivariate.py:1994                                              \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Suppress : warnings.simplefilter('ignore', category=DataTransformationWarning)       \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m╰──────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>level</th>\n",
       "      <th>so2_lag_1</th>\n",
       "      <th>so2_lag_2</th>\n",
       "      <th>so2_lag_3</th>\n",
       "      <th>so2_roll_mean_5</th>\n",
       "      <th>so2_roll_sum_5</th>\n",
       "      <th>co_lag_1</th>\n",
       "      <th>co_lag_2</th>\n",
       "      <th>co_lag_3</th>\n",
       "      <th>co_roll_mean_5</th>\n",
       "      <th>...</th>\n",
       "      <th>direc._lag_1</th>\n",
       "      <th>direc._lag_2</th>\n",
       "      <th>direc._lag_3</th>\n",
       "      <th>direc._roll_mean_5</th>\n",
       "      <th>direc._roll_sum_5</th>\n",
       "      <th>pm2.5_lag_1</th>\n",
       "      <th>pm2.5_lag_2</th>\n",
       "      <th>pm2.5_lag_3</th>\n",
       "      <th>pm2.5_roll_mean_5</th>\n",
       "      <th>pm2.5_roll_sum_5</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2024-01-01 00:00:00</th>\n",
       "      <td>co</td>\n",
       "      <td>-0.684809</td>\n",
       "      <td>-0.684809</td>\n",
       "      <td>-0.684809</td>\n",
       "      <td>-0.684809</td>\n",
       "      <td>-3.424043</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>...</td>\n",
       "      <td>0.790282</td>\n",
       "      <td>0.780587</td>\n",
       "      <td>0.790282</td>\n",
       "      <td>0.770892</td>\n",
       "      <td>3.85446</td>\n",
       "      <td>-0.631026</td>\n",
       "      <td>-0.510866</td>\n",
       "      <td>-0.631026</td>\n",
       "      <td>-0.486834</td>\n",
       "      <td>-2.43417</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-01-01 01:00:00</th>\n",
       "      <td>co</td>\n",
       "      <td>-0.684809</td>\n",
       "      <td>-0.684809</td>\n",
       "      <td>-0.684809</td>\n",
       "      <td>-0.684809</td>\n",
       "      <td>-3.424043</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>...</td>\n",
       "      <td>0.790282</td>\n",
       "      <td>0.780587</td>\n",
       "      <td>0.790282</td>\n",
       "      <td>0.770892</td>\n",
       "      <td>3.85446</td>\n",
       "      <td>-0.631026</td>\n",
       "      <td>-0.510866</td>\n",
       "      <td>-0.631026</td>\n",
       "      <td>-0.486834</td>\n",
       "      <td>-2.43417</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-01-01 02:00:00</th>\n",
       "      <td>co</td>\n",
       "      <td>-0.684809</td>\n",
       "      <td>-0.684809</td>\n",
       "      <td>-0.684809</td>\n",
       "      <td>-0.684809</td>\n",
       "      <td>-3.424043</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>-0.447961</td>\n",
       "      <td>...</td>\n",
       "      <td>0.790282</td>\n",
       "      <td>0.780587</td>\n",
       "      <td>0.790282</td>\n",
       "      <td>0.770892</td>\n",
       "      <td>3.85446</td>\n",
       "      <td>-0.631026</td>\n",
       "      <td>-0.510866</td>\n",
       "      <td>-0.631026</td>\n",
       "      <td>-0.486834</td>\n",
       "      <td>-2.43417</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>3 rows × 51 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                    level  so2_lag_1  so2_lag_2  so2_lag_3  so2_roll_mean_5  \\\n",
       "2024-01-01 00:00:00    co  -0.684809  -0.684809  -0.684809        -0.684809   \n",
       "2024-01-01 01:00:00    co  -0.684809  -0.684809  -0.684809        -0.684809   \n",
       "2024-01-01 02:00:00    co  -0.684809  -0.684809  -0.684809        -0.684809   \n",
       "\n",
       "                     so2_roll_sum_5  co_lag_1  co_lag_2  co_lag_3  \\\n",
       "2024-01-01 00:00:00       -3.424043 -0.447961 -0.447961 -0.447961   \n",
       "2024-01-01 01:00:00       -3.424043 -0.447961 -0.447961 -0.447961   \n",
       "2024-01-01 02:00:00       -3.424043 -0.447961 -0.447961 -0.447961   \n",
       "\n",
       "                     co_roll_mean_5  ...  direc._lag_1  direc._lag_2  \\\n",
       "2024-01-01 00:00:00       -0.447961  ...      0.790282      0.780587   \n",
       "2024-01-01 01:00:00       -0.447961  ...      0.790282      0.780587   \n",
       "2024-01-01 02:00:00       -0.447961  ...      0.790282      0.780587   \n",
       "\n",
       "                     direc._lag_3  direc._roll_mean_5  direc._roll_sum_5  \\\n",
       "2024-01-01 00:00:00      0.790282            0.770892            3.85446   \n",
       "2024-01-01 01:00:00      0.790282            0.770892            3.85446   \n",
       "2024-01-01 02:00:00      0.790282            0.770892            3.85446   \n",
       "\n",
       "                     pm2.5_lag_1  pm2.5_lag_2  pm2.5_lag_3  pm2.5_roll_mean_5  \\\n",
       "2024-01-01 00:00:00    -0.631026    -0.510866    -0.631026          -0.486834   \n",
       "2024-01-01 01:00:00    -0.631026    -0.510866    -0.631026          -0.486834   \n",
       "2024-01-01 02:00:00    -0.631026    -0.510866    -0.631026          -0.486834   \n",
       "\n",
       "                     pm2.5_roll_sum_5  \n",
       "2024-01-01 00:00:00          -2.43417  \n",
       "2024-01-01 01:00:00          -2.43417  \n",
       "2024-01-01 02:00:00          -2.43417  \n",
       "\n",
       "[3 rows x 51 columns]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create input matrix for predict method\n",
    "# ==============================================================================\n",
    "X_predict = forecaster.create_predict_X(steps=None)  # All steps\n",
    "X_predict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.37588817, -0.37588817, -0.37588817])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Step 1 predictions using the internal estimator\n",
    "# ==============================================================================\n",
    "predictions = forecaster.estimators_[1].predict(X_predict.drop(columns='level'))\n",
    "predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating matrices when including transformations multiple series\n",
    "\n",
    "If any [data transformations](../user_guides/sklearn-transformers-and-pipeline.html) and/or [differentiation](../user_guides/time-series-differentiation.html), are applied, they will affect the output matrices. Consequently, the predictions generated in this transformed scale may require additional steps to revert back to the original data scale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╭────────────────────────────────── InputTypeWarning ──────────────────────────────────╮</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Passing a DataFrame (either wide or long format) as `series` requires additional     <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> internal transformations, which can increase computational time. It is recommended   <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> to use a dictionary of pandas Series instead. For more details, see:                 <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> https://skforecast.org/latest/user_guides/independent-multi-time-series-forecasting. <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> html#input-data                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>                                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Category : skforecast.exceptions.InputTypeWarning                                    <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Location :                                                                           <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\utils\\u <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> tils.py:2349                                                                         <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Suppress : warnings.simplefilter('ignore', category=InputTypeWarning)                <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╰──────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[38;5;214m╭─\u001b[0m\u001b[38;5;214m─────────────────────────────────\u001b[0m\u001b[38;5;214m InputTypeWarning \u001b[0m\u001b[38;5;214m─────────────────────────────────\u001b[0m\u001b[38;5;214m─╮\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Passing a DataFrame (either wide or long format) as `series` requires additional     \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m internal transformations, which can increase computational time. It is recommended   \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m to use a dictionary of pandas Series instead. For more details, see:                 \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m https://skforecast.org/latest/user_guides/independent-multi-time-series-forecasting. \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m html#input-data                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m                                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Category : skforecast.exceptions.InputTypeWarning                                    \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Location :                                                                           \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\utils\\u \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m tils.py:2349                                                                         \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Suppress : warnings.simplefilter('ignore', category=InputTypeWarning)                \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m╰──────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create and fit forecaster ForecasterRecursiveMultiSeries\n",
    "# ==============================================================================\n",
    "window_features = RollingFeatures(\n",
    "                      stats        = ['mean', 'sum'],\n",
    "                      window_sizes = [5, 5]\n",
    "                  )\n",
    "\n",
    "forecaster = ForecasterRecursiveMultiSeries(\n",
    "                 estimator          = LGBMRegressor(random_state=123, verbose=-1),\n",
    "                 lags               = 5,\n",
    "                 window_features    = window_features,\n",
    "                 encoding           = 'ordinal',\n",
    "                 transformer_series = StandardScaler(),\n",
    "                 differentiation    = 1\n",
    "             )\n",
    "\n",
    "forecaster.fit(series=data_multiseries)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╭────────────────────────────────── InputTypeWarning ──────────────────────────────────╮</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Passing a DataFrame (either wide or long format) as `series` requires additional     <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> internal transformations, which can increase computational time. It is recommended   <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> to use a dictionary of pandas Series instead. For more details, see:                 <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> https://skforecast.org/latest/user_guides/independent-multi-time-series-forecasting. <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> html#input-data                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>                                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Category : skforecast.exceptions.InputTypeWarning                                    <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Location :                                                                           <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\utils\\u <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> tils.py:2349                                                                         <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Suppress : warnings.simplefilter('ignore', category=InputTypeWarning)                <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╰──────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[38;5;214m╭─\u001b[0m\u001b[38;5;214m─────────────────────────────────\u001b[0m\u001b[38;5;214m InputTypeWarning \u001b[0m\u001b[38;5;214m─────────────────────────────────\u001b[0m\u001b[38;5;214m─╮\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Passing a DataFrame (either wide or long format) as `series` requires additional     \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m internal transformations, which can increase computational time. It is recommended   \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m to use a dictionary of pandas Series instead. For more details, see:                 \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m https://skforecast.org/latest/user_guides/independent-multi-time-series-forecasting. \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m html#input-data                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m                                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Category : skforecast.exceptions.InputTypeWarning                                    \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Location :                                                                           \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\utils\\u \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m tils.py:2349                                                                         \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Suppress : warnings.simplefilter('ignore', category=InputTypeWarning)                \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m╰──────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ordinal encoding mapping (_level_skforecast) : {'item_1': 0, 'item_2': 1, 'item_3': 2}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([19.03003376, 19.87765376, 20.27301849, 21.50016429])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# item_1 training predictions with transformations\n",
    "# ==============================================================================\n",
    "X_train_transformed, y_train_transformed = forecaster.create_train_X_y(series=data_multiseries)\n",
    "\n",
    "# Ordinal encoding mapping \n",
    "print(\"Ordinal encoding mapping (_level_skforecast) :\", forecaster.encoding_mapping_)\n",
    "\n",
    "# Select `item_1` rows\n",
    "X_train_item_1_transformed = X_train_transformed[\n",
    "    X_train_transformed['_level_skforecast'] == forecaster.encoding_mapping_['item_1']\n",
    "]\n",
    "\n",
    "# Training predictions using the internal estimator\n",
    "predictions_item_1_transformed = forecaster.estimator.predict(X_train_item_1_transformed)\n",
    "\n",
    "# Revert differentiation (only if differentiation is not None)\n",
    "predictions_item_1_transformed = forecaster.differentiator_['item_1'].inverse_transform_training(\n",
    "    predictions_item_1_transformed\n",
    ")\n",
    "\n",
    "# Revert transformation (only if transformer_series is not None)\n",
    "predictions_item_1_training = forecaster.transformer_series_['item_1'].inverse_transform(\n",
    "    predictions_item_1_transformed.reshape(-1, 1)\n",
    ")\n",
    "predictions_item_1_training.ravel()[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╭───────────────────────────── DataTransformationWarning ──────────────────────────────╮</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> The output matrix is in the transformed scale due to the inclusion of                <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> transformations or differentiation in the Forecaster. As a result, any predictions   <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> generated using this matrix will also be in the transformed scale. Please refer to   <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> the documentation for more details:                                                  <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> https://skforecast.org/latest/user_guides/training-and-prediction-matrices.html      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>                                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Category : skforecast.exceptions.DataTransformationWarning                           <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Location :                                                                           <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\recursi <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> ve\\_forecaster_recursive_multiseries.py:2540                                         <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Suppress : warnings.simplefilter('ignore', category=DataTransformationWarning)       <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╰──────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[38;5;214m╭─\u001b[0m\u001b[38;5;214m────────────────────────────\u001b[0m\u001b[38;5;214m DataTransformationWarning \u001b[0m\u001b[38;5;214m─────────────────────────────\u001b[0m\u001b[38;5;214m─╮\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m The output matrix is in the transformed scale due to the inclusion of                \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m transformations or differentiation in the Forecaster. As a result, any predictions   \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m generated using this matrix will also be in the transformed scale. Please refer to   \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m the documentation for more details:                                                  \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m https://skforecast.org/latest/user_guides/training-and-prediction-matrices.html      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m                                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Category : skforecast.exceptions.DataTransformationWarning                           \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Location :                                                                           \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\recursi \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m ve\\_forecaster_recursive_multiseries.py:2540                                         \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Suppress : warnings.simplefilter('ignore', category=DataTransformationWarning)       \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m╰──────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([11.9118058 , 13.90669023, 14.61048366, 14.68379556])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Predict using the internal estimator with transformation\n",
    "# ==============================================================================\n",
    "X_predict_dict_transformed = forecaster.create_predict_X(steps=5, levels=None)  # All levels\n",
    "\n",
    "# Select 'item_1' matrix\n",
    "X_predict_item_1_transformed = X_predict_dict_transformed.query(\"level == 'item_1'\").drop(columns='level')\n",
    "\n",
    "# Predict 'item_1' using the internal estimator\n",
    "predictions_item_1_transformed = forecaster.estimator.predict(X_predict_item_1_transformed)\n",
    "\n",
    "# Revert differentiation (only if differentiation is not None)\n",
    "predictions_item_1_transformed = forecaster.differentiator_['item_1'].inverse_transform_next_window(\n",
    "    predictions_item_1_transformed\n",
    ")\n",
    "\n",
    "# Revert transformation (only if transformer_series is not None)\n",
    "predictions_item_1 = forecaster.transformer_series_['item_1'].inverse_transform(\n",
    "    predictions_item_1_transformed.reshape(-1, 1)\n",
    ")\n",
    "predictions_item_1.ravel()[:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As before, when using a <code>ForecasterDirectMultiVariate</code>, two steps are required to extract the training matrices. One to create the entire training matrix and a second to subset the data needed for each model (step)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"admonition note\" name=\"html-admonition\" style=\"background: rgba(255,145,0,.1); padding-top: 0px; padding-bottom: 6px; border-radius: 8px; border-left: 8px solid #ff9100; border-color: #ff9100; padding-left: 10px; padding-right: 10px\">\n",
    "\n",
    "<p class=\"title\">\n",
    "    <i style=\"font-size: 18px; color:#ff9100; border-color: #ff1744;\"></i>\n",
    "    <b style=\"color: #ff9100;\"> <span style=\"color: #ff9100;\">&#9888;</span> Warning</b>\n",
    "</p>\n",
    "\n",
    "If the <code>ForecasterDirectMultiVariate</code> includes <a href=\"../user_guides/time-series-differentiation.html\">differentiation</a>, the model in step 1 must be used if you want to reverse the differentiation of the training time series with the <code>inverse_transform_training</code> method.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create and fit forecaster\n",
    "# ==============================================================================\n",
    "window_features = RollingFeatures(\n",
    "                      stats        = ['mean', 'sum'],\n",
    "                      window_sizes = [5, 5]\n",
    "                  )\n",
    "\n",
    "forecaster = ForecasterDirectMultiVariate(\n",
    "                 estimator          = Ridge(random_state=123),\n",
    "                 level              = 'co',\n",
    "                 steps              = 3,\n",
    "                 lags               = 3,\n",
    "                 window_features    = window_features,\n",
    "                 transformer_series = StandardScaler(),\n",
    "                 differentiation    = 1\n",
    "             )\n",
    "\n",
    "forecaster.fit(series=data_multivariate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.09856102, 0.09112238, 0.09364988, 0.09022939])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Training predictions with transformations\n",
    "# ==============================================================================\n",
    "X_train_transformed, y_train_transformed = forecaster.create_train_X_y(series=data_multivariate)\n",
    "\n",
    "# Extract X and y for step 1\n",
    "X_train_transformed_1, y_train_transformed_1 = forecaster.filter_train_X_y_for_step(\n",
    "                                                   step          = 1,\n",
    "                                                   X_train       = X_train_transformed,\n",
    "                                                   y_train       = y_train_transformed,\n",
    "                                                   remove_suffix = False\n",
    "                                               )\n",
    "\n",
    "# Training predictions using the internal estimator for step 1\n",
    "predictions_transformed = forecaster.estimators_[1].predict(X_train_transformed_1)\n",
    "\n",
    "# Revert differentiation (only if differentiation is not None)\n",
    "predictions_transformed = forecaster.differentiator_['co'].inverse_transform_training(\n",
    "    predictions_transformed\n",
    ")\n",
    "\n",
    "# Revert transformation (only if transformer_series is not None)\n",
    "predictions_training = forecaster.transformer_series_['co'].inverse_transform(\n",
    "    predictions_transformed.reshape(-1, 1)\n",
    ")\n",
    "predictions_training.ravel()[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╭───────────────────────────── DataTransformationWarning ──────────────────────────────╮</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> The output matrix is in the transformed scale due to the inclusion of                <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> transformations or differentiation in the Forecaster. As a result, any predictions   <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> generated using this matrix will also be in the transformed scale. Please refer to   <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> the documentation for more details:                                                  <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> https://skforecast.org/latest/user_guides/training-and-prediction-matrices.html      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>                                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Category : skforecast.exceptions.DataTransformationWarning                           <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Location :                                                                           <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\direct\\ <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> _forecaster_direct_multivariate.py:1994                                              <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Suppress : warnings.simplefilter('ignore', category=DataTransformationWarning)       <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╰──────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[38;5;214m╭─\u001b[0m\u001b[38;5;214m────────────────────────────\u001b[0m\u001b[38;5;214m DataTransformationWarning \u001b[0m\u001b[38;5;214m─────────────────────────────\u001b[0m\u001b[38;5;214m─╮\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m The output matrix is in the transformed scale due to the inclusion of                \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m transformations or differentiation in the Forecaster. As a result, any predictions   \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m generated using this matrix will also be in the transformed scale. Please refer to   \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m the documentation for more details:                                                  \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m https://skforecast.org/latest/user_guides/training-and-prediction-matrices.html      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m                                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Category : skforecast.exceptions.DataTransformationWarning                           \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Location :                                                                           \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\direct\\ \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m _forecaster_direct_multivariate.py:1994                                              \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Suppress : warnings.simplefilter('ignore', category=DataTransformationWarning)       \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m╰──────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([0.1004134 , 0.10082681, 0.10124021])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Predict using the internal estimator with transformation\n",
    "# ==============================================================================\n",
    "X_predict_transformed = forecaster.create_predict_X(steps=None)  # All steps\n",
    "\n",
    "# Predict using the internal estimator for step 1\n",
    "predictions_transformed = forecaster.estimators_[1].predict(X_predict_transformed.drop(columns='level'))\n",
    "\n",
    "# Revert differentiation (only if differentiation is not None)\n",
    "predictions_transformed = forecaster.differentiator_['co'].inverse_transform_next_window(\n",
    "    predictions_transformed\n",
    ")\n",
    "\n",
    "# Revert transformation (only if transformer_y is not None)\n",
    "predictions = forecaster.transformer_series_['co'].inverse_transform(\n",
    "    predictions_transformed.reshape(-1, 1)\n",
    ")\n",
    "predictions.ravel()[:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"admonition note\" name=\"html-admonition\" style=\"background: rgba(0,191,191,.1); padding-top: 0px; padding-bottom: 6px; border-radius: 8px; border-left: 8px solid #00bfa5; border-color: #00bfa5; padding-left: 10px; padding-right: 10px;\">\n",
    "\n",
    "<p class=\"title\">\n",
    "    <i style=\"font-size: 18px; color:#00bfa5;\"></i>\n",
    "    <b style=\"color: #00bfa5;\">&#128161 Tip</b>\n",
    "</p>\n",
    "\n",
    "To reverse the <a href=\"../user_guides/sklearn-transformers-and-pipeline.html\">data transformation</a>, you can also use one of these skforecast functions: <a href=\"../api/utils.html#skforecast.utils.utils.transform_numpy\"><code>transform_numpy</code></a>, <a href=\"../api/utils.html#skforecast.utils.utils.transform_series\"><code>transform_series</code></a>, <a href=\"../api/utils.html#skforecast.utils.utils.transform_dataframe\"><code>transform_dataframe</code></a>.\n",
    "\n",
    "```python\n",
    "from skforecast.utils import transform_numpy\n",
    "\n",
    "predictions = transform_numpy(\n",
    "                  array             = predictions_transformed,\n",
    "                  transformer       = forecaster.transformer_series_['item_1'],\n",
    "                  fit               = False,\n",
    "                  inverse_transform = True\n",
    "              )\n",
    "```\n",
    "\n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "skforecast_py12",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
